ACE/ace/Local_Tokens.inl

   1 // -*- C++ -*-
   2 #if defined (ACE_HAS_TOKENS_LIBRARY)
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 // ************************************************************
   7
   8 ACE_INLINE int
   9 ACE_Token_Proxy_Queue::size (void)
  10 {
  11   ACE_TRACE ("ACE_Token_Proxy_Queue::size");
  12   return this->size_;
  13 }
  14
  15 // ************************************************************
  16
  17 ACE_INLINE int
  18 ACE_TPQ_Entry::waiting (void) const
  19 {
  20   ACE_TRACE ("ACE_TPQ_Entry::waiting");
  21   return waiting_;
  22 }
  23
  24 ACE_INLINE void
  25 ACE_TPQ_Entry::waiting (int v)
  26 {
  27   ACE_TRACE ("ACE_TPQ_Entry::waiting");
  28   waiting_ = v;
  29 }
  30
  31 ACE_INLINE const ACE_TCHAR *
  32 ACE_TPQ_Entry::client_id (void) const
  33 {
  34   ACE_TRACE ("ACE_TPQ_Entry::client_id");
  35   return this->client_id_;
  36 }
  37
  38 ACE_INLINE ACE_Token_Proxy *
  39 ACE_TPQ_Entry::proxy (void) const
  40 {
  41   ACE_TRACE ("ACE_TPQ_Entry::proxy");
  42   return this->proxy_;
  43 }
  44
  45 ACE_INLINE void
  46 ACE_TPQ_Entry::proxy (ACE_Token_Proxy *proxy)
  47 {
  48   ACE_TRACE ("ACE_TPQ_Entry::proxy");
  49   this->proxy_ = proxy;
  50 }
  51
  52 ACE_INLINE
  53 ACE_TPQ_Iterator::~ACE_TPQ_Iterator (void)
  54 {
  55 }
  56
  57 ACE_INLINE
  58 ACE_Token_Proxy_Queue::~ACE_Token_Proxy_Queue (void)
  59 {
  60 }
  61
  62 ACE_INLINE void
  63 ACE_Tokens::remove (ACE_TPQ_Entry *caller)
  64 {
  65   this->waiters_.remove (caller);
  66 }
  67
  68 ACE_INLINE int
  69 ACE_Tokens::dec_reference (void)
  70 {
  71   ACE_TRACE ("ACE_Tokens::dec_reference");
  72   if (this->reference_count_ == 0)
  73     {
  74       ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("dec_reference already zero")));
  75       return 0;
  76     }
  77
  78   return --this->reference_count_;
  79 }
  80
  81 ACE_INLINE void
  82 ACE_Tokens::inc_reference (void)
  83 {
  84   ACE_TRACE ("ACE_Tokens::inc_reference");
  85   ++this->reference_count_;
  86 }
  87
  88 ACE_INLINE const ACE_TPQ_Entry *
  89 ACE_Token_Proxy_Queue::head (void)
  90 {
  91   ACE_TRACE ("ACE_Token_Proxy_Queue::head");
  92   if (this->head_ == 0)
  93     return 0;
  94   else
  95     return this->head_;
  96 }
  97
  98 // **************************************************
  99 // **************************************************
 100 // **************************************************
 101
 102 ACE_INLINE void
 103 ACE_Tokens::visit (int v)
 104 {
 105   ACE_TRACE ("ACE_Tokens::visit");
 106   visited_ = v;
 107 }
 108
 109 ACE_INLINE int
 110 ACE_Tokens::visited (void)
 111 {
 112   ACE_TRACE ("ACE_Tokens::visited");
 113   return visited_;
 114 }
 115
 116 ACE_INLINE ACE_TPQ_Entry *
 117 ACE_Tokens::owner (void)
 118 {
 119   ACE_TRACE ("ACE_Tokens::owner");
 120   return (ACE_TPQ_Entry *) this->waiters_.head ();
 121 }
 122
 123 ACE_INLINE const ACE_TCHAR*
 124 ACE_Tokens::owner_id ()
 125 {
 126   ACE_TRACE ("ACE_Tokens::owner_id");
 127   if (this->owner () == 0)
 128     return ACE_TEXT ("no owner");
 129   else
 130     return this->owner ()->client_id ();
 131 }
 132
 133 ACE_INLINE const ACE_TCHAR*
 134 ACE_Tokens::name (void)
 135 {
 136   ACE_TRACE ("ACE_Tokens::name");
 137   return this->token_name_;
 138 }
 139
 140 // ************************************************************
 141
 142 ACE_INLINE int
 143 ACE_TPQ_Entry::nesting_level (void) const
 144 {
 145   ACE_TRACE ("ACE_TPQ_Entry::nesting_level");
 146   return this->nesting_level_;
 147 }
 148
 149 ACE_INLINE void
 150 ACE_TPQ_Entry::nesting_level (int delta)
 151 {
 152   ACE_TRACE ("ACE_TPQ_Entry::nesting_level");
 153   this->nesting_level_ += delta;
 154 }
 155
 156 ACE_INLINE ACE_TPQ_Entry::PTVF
 157 ACE_TPQ_Entry::sleep_hook (void) const
 158 {
 159   ACE_TRACE ("ACE_TPQ_Entry::sleep_hook");
 160   return this->sleep_hook_;
 161 }
 162
 163 ACE_INLINE void
 164 ACE_TPQ_Entry::sleep_hook (void (*sh)(void *))
 165 {
 166   ACE_TRACE ("ACE_TPQ_Entry::sleep_hook");
 167   this->sleep_hook_ = sh;
 168 }
 169
 170 ACE_INLINE void
 171 ACE_TPQ_Entry::call_sleep_hook (void)
 172 {
 173   ACE_TRACE ("ACE_TPQ_Entry::call_sleep_hook");
 174
 175   // if a function has been registered, call it.
 176   if (this->sleep_hook () != 0)
 177     this->sleep_hook () ((void *) this->proxy ());
 178   else
 179     // otherwise, call back the sleep_hook method
 180     this->proxy ()->sleep_hook ();
 181 }
 182
 183 ACE_INLINE int
 184 ACE_TPQ_Entry::equal_client_id (const ACE_TCHAR *id)
 185 {
 186   ACE_TRACE ("ACE_TPQ_Entry::equal_client_id");
 187   return (ACE_OS::strcmp (this->client_id (), id) == 0);
 188 }
 189
 190 // ************************************************************
 191 // ************************************************************
 192 // ************************************************************
 193
 194 ACE_INLINE
 195 ACE_Local_Mutex::ACE_Local_Mutex (const ACE_TCHAR *token_name,
 196                                   int ignore_deadlock,
 197                                   int debug)
 198 {
 199   ACE_TRACE ("ACE_Local_Mutex::ACE_Local_Mutex");
 200   this->open (token_name, ignore_deadlock, debug);
 201 }
 202
 203 ACE_INLINE void
 204 ACE_Token_Name::name (const ACE_TCHAR *new_name)
 205 {
 206   ACE_TRACE ("ACE_Token_Name::name");
 207
 208   if (new_name == 0)
 209     new_name = ACE_TEXT ("no name");
 210
 211   size_t n = ACE_OS::strlen (new_name) + 1;
 212
 213   if (n >= ACE_MAXTOKENNAMELEN)
 214     n = ACE_MAXTOKENNAMELEN - 1;
 215
 216   ACE_OS::strsncpy (this->token_name_, (ACE_TCHAR *) new_name, n);
 217 }
 218
 219 ACE_INLINE const ACE_TCHAR*
 220 ACE_Token_Name::name (void) const
 221 {
 222   ACE_TRACE ("ACE_Token_Name::name");
 223   return this->token_name_;
 224 }
 225
 226 // ************************************************************
 227
 228 ACE_INLINE
 229 ACE_Local_RLock::ACE_Local_RLock (const ACE_TCHAR *token_name,
 230                                   int ignore_deadlock,
 231                                   int debug)
 232 {
 233   ACE_TRACE ("ACE_Local_RLock::ACE_Local_RLock");
 234   this->open (token_name, ignore_deadlock, debug);
 235 }
 236
 237 // ************************************************************
 238
 239 ACE_INLINE
 240 ACE_Local_WLock::ACE_Local_WLock (const ACE_TCHAR *token_name,
 241                                   int ignore_deadlock,
 242                                   int debug)
 243 {
 244   ACE_TRACE ("ACE_Local_WLock::ACE_Local_WLock");
 245   this->open (token_name, ignore_deadlock, debug);
 246 }
 247
 248 // ************************************************************
 249
 250
 251 ACE_INLINE void
 252 ACE_Token_Name::operator= (const ACE_Token_Name &rhs)
 253 {
 254   ACE_TRACE ("ACE_Token_Name::operator=");
 255   if (&rhs == this)
 256     return;
 257   else
 258     this->name (rhs.name ());
 259 }
 260
 261 ACE_INLINE bool
 262 ACE_Token_Name::operator== (const ACE_Token_Name &rhs) const
 263 {
 264   ACE_TRACE ("ACE_Token_Name::operator==");
 265
 266   // the name and type must be the same
 267   return (ACE_OS::strcmp (this->token_name_, rhs.name ()) == 0);
 268 }
 269
 270 ACE_END_VERSIONED_NAMESPACE_DECL
 271
 272 #endif /* ACE_HAS_TOKENS_LIBRARY */