TAO_EC_Thread_Flags Class Reference

Parse thread flags from string to a long. More...

#include <EC_Thread_Flags.h>

Collaboration diagram for TAO_EC_Thread_Flags:

[legend]List of all members.

Public Member Functions
	TAO_EC_Thread_Flags ()
	TAO_EC_Thread_Flags (const char *symbolic_flags)
	See operator=().
	~TAO_EC_Thread_Flags ()
const TAO_EC_Thread_Flags &	operator= (const char *symbolic_flags)
	Assign a new set of symbolic flags, setting flags, scope, and sched as possible.
long	flags () const
	Returns numeric equivalent of the thread flags suitable for passing to ACE_Task::activate.
long	scope () const
	Returns value of THR_SCOPE_* used, or zero if unknown.
long	sched () const
	Returns value of THR_SCHED_* used, or zero if unknown.
	operator long () const
	Synonym for flags(), i.e., syntactic sugar.
long	default_priority () const
	Return an acceptable default priority for the scheduler returned by sched().
Static Public Attributes
static Supported_Flag	supported_flags_ []
Protected Member Functions
void	parse_symbols (const char *syms)
	Value of THR_SCHED_*.
Protected Attributes
long	flags_
long	scope_
	Value of all flags OR'd together.
long	sched_
	Value of THR_SCOPE_*.
Classes
struct	Supported_Flag

---

Detailed Description

Parse thread flags from string to a long.

Encapsulate flags used for creating threads with ACE_OS::thr_create and ACE_Task::activate.

Note:

On platforms that do not support the thread schedulers, the ACE OS adaptation layer preserves the symbols for THR_SCHED_*, but defines them as zero. Thus, on such platforms, setting a scheduler in the flags, then inquiring for the scheduler type will yield the same result as an unknown or unset scheduler.

This should really be part of ACE or ACE_OS, and maybe someday it will, but right now it's not.

Definition at line 44 of file EC_Thread_Flags.h.

---

Constructor & Destructor Documentation

TAO_EC_Thread_Flags::TAO_EC_Thread_Flags

(

)

[inline]

Definition at line 47 of file EC_Thread_Flags.h.

{ }

TAO_EC_Thread_Flags::TAO_EC_Thread_Flags

(

const char *

symbolic_flags

)

[inline]

See operator=().

Definition at line 49 of file EC_Thread_Flags.h.

    { this->parse_symbols(symbolic_flags); }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_EC_Thread_Flags::~TAO_EC_Thread_Flags

(

)

Definition at line 38 of file EC_Thread_Flags.cpp.

{
}

---

Member Function Documentation

long TAO_EC_Thread_Flags::default_priority

(

)

const

Return an acceptable default priority for the scheduler returned by sched().

Returns:

the priority, or ACE_DEFAULT_THREAD_PRIORITY if the scheduler is unknown.

Definition at line 126 of file EC_Thread_Flags.cpp.

References ACE_DEFAULT_THREAD_PRIORITY, ACE_Sched_Params::next_priority(), ACE_Sched_Params::priority_max(), and ACE_Sched_Params::priority_min().

Referenced by TAO_EC_Default_Factory::init().

{
  long priority = ACE_DEFAULT_THREAD_PRIORITY;

  // use the implementation
  if (this->sched() == 0)
    return priority;

  priority =
    ACE_Sched_Params::priority_min (this->sched()) +
    ACE_Sched_Params::priority_max (this->sched()) / 2;
  priority = ACE_Sched_Params::next_priority (this->sched(), priority);

  return priority;
}

long TAO_EC_Thread_Flags::flags

(

void

)

const [inline]

Returns numeric equivalent of the thread flags suitable for passing to ACE_Task::activate.

Definition at line 73 of file EC_Thread_Flags.h.

Referenced by TAO_EC_Default_Factory::init().

{ return this->flags_; }

TAO_EC_Thread_Flags::operator long

(

)

const [inline]

Synonym for flags(), i.e., syntactic sugar.

Definition at line 86 of file EC_Thread_Flags.h.

{ return this->flags(); }

const TAO_EC_Thread_Flags& TAO_EC_Thread_Flags::operator=

(

const char *

symbolic_flags

)

[inline]

Assign a new set of symbolic flags, setting flags, scope, and sched as possible.

The flags can be symbolic, separated by the vertical bar ('|'). In case a platform supports a creation flag not available symbolically, the user can specify a numeric value any place a symbol could be used.

See also:

TAO_EC_Thread_Flags::supported_flags

Note:

The sched value only gets set if the scheduler is specified using symbols.

Definition at line 67 of file EC_Thread_Flags.h.

    { this->parse_symbols(symbolic_flags); return *this; }

void TAO_EC_Thread_Flags::parse_symbols

(

const char *

syms

)

[protected]

Value of THR_SCHED_*.

Definition at line 43 of file EC_Thread_Flags.cpp.

References ACE_ERROR, flags_, ACE_OS::free(), LM_ERROR, sched_, scope_, strcasecmp(), strdup(), strtok_r(), strtol(), supported_flags_, THR_SCHED_DEFAULT, THR_SCHED_FIFO, THR_SCHED_RR, THR_SCOPE_PROCESS, THR_SCOPE_SYSTEM, and TAO_EC_Thread_Flags::Supported_Flag::v.

{
  // PRE: we assume nothing other than that syms is valid
  // POST:
  // 1. flags_ is bitwise-OR of all flags
  // 2. sched_ is THR_SCHED_*, or THR_SCHED_DEFAULT if not specified
  // 3. scope_ is THR_SCOPE_*, or THR_SCOPE_PROCESS if not specified

  // NOTE: I'm not sure if #2 and #3 are consistent with what happens
  // in ACE_Task::activate.  I really need to double-check that, and
  // make sure that they are consistent.

  flags_ = scope_ = sched_ = 0; // zero out everything

  // short-circuit on the trivial case
  if (syms == 0 || *syms == '\0')
    return;

  static size_t num_flags = sizeof(supported_flags_)/sizeof(Supported_Flag);
  char* s = ACE_OS_String::strdup (syms); // need a mutable string
  if (s == 0)
    return;

  const char* SEPARATORS = " |"; // this should probably be at class level
  char* ptr = 0;
  char* tok = ACE_OS_String::strtok_r (s, SEPARATORS, &ptr);
  while (tok != 0)
    {
      // This would allow for easy accomodation of flags that
      // aren't currently supported, but is it a good idea?

      if (tok[0] >= '0' && tok[0] <= '9') // Numeric, so just accept it!
        {
          // parse it as a long straight to the flags
 
          // If somebody specifies the scheduler this way, then they
          // lose range checking on the priority.  Bummer, but those
          // are the breaks.
          this->flags_ |= ACE_OS_String::strtol (tok, 0, 0);
        }
      else
        {
          int found = 0;
          for (size_t i = 0; !found && i < num_flags; ++i)
            {
              if (ACE_OS_String::strcasecmp (tok, supported_flags_[i].n) == 0)
                {
                  this->flags_ |= supported_flags_[i].v;

                  // Can't use a switch for this b/c for some
                  // platforms the THR_* constants end up with
                  // the same values, and compiles get upset.
                  long &sf = supported_flags_[i].v;
                  if (sf == THR_SCHED_FIFO ||
                      sf == THR_SCHED_RR ||
                      sf == THR_SCHED_DEFAULT)
                    {
                      this->sched_ = supported_flags_[i].v;
                    }
                  else if (sf == THR_SCOPE_SYSTEM ||
                           sf == THR_SCOPE_PROCESS)
                    {
                      this->scope_ = supported_flags_[i].v;
                    }
                  found = 1;
                }
            }
          if (!found)
            {
              // Ideally this would call some sort of on-error function...
              // but, it doesn't.
              ACE_ERROR ((LM_ERROR,
                          "RTEC (%P|%t) unable to parse %s as a thread flag - skipping\n",
                          tok));
            }
        }
      tok = ACE_OS_String::strtok_r (0, SEPARATORS, &ptr);
    }

  ACE_OS::free (s); // clean up after ourselves
}

long TAO_EC_Thread_Flags::sched

(

)

const [inline]

Returns value of THR_SCHED_* used, or zero if unknown.

Definition at line 83 of file EC_Thread_Flags.h.

{ return this->sched_; }

long TAO_EC_Thread_Flags::scope

(

)

const [inline]

Returns value of THR_SCOPE_* used, or zero if unknown.

Definition at line 78 of file EC_Thread_Flags.h.

{ return this->scope_; }

---

Member Data Documentation

long TAO_EC_Thread_Flags::flags_ [protected]

Definition at line 106 of file EC_Thread_Flags.h.

Referenced by parse_symbols().

long TAO_EC_Thread_Flags::sched_ [protected]

Value of THR_SCOPE_*.

Definition at line 108 of file EC_Thread_Flags.h.

Referenced by parse_symbols().

long TAO_EC_Thread_Flags::scope_ [protected]

Value of all flags OR'd together.

Definition at line 107 of file EC_Thread_Flags.h.

Referenced by parse_symbols().

TAO_EC_Thread_Flags::Supported_Flag TAO_EC_Thread_Flags::supported_flags_ [static]

Initial value:

 {

















 
  }

Definition at line 103 of file EC_Thread_Flags.h.

Referenced by parse_symbols().

---

The documentation for this class was generated from the following files:

• EC_Thread_Flags.h
• EC_Thread_Flags.cpp

---