ACE/ace/Token_Collection.cpp

   1 #include "ace/Token_Collection.h"
   2
   3 #if defined (ACE_HAS_TOKENS_LIBRARY)
   4
   5 #if !defined (__ACE_INLINE__)
   6 #include "ace/Token_Collection.inl"
   7 #endif /* __ACE_INLINE__ */
   8
   9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  10
  11 ACE_Token_Collection::ACE_Token_Collection (bool debug,
  12                                             const ACE_TCHAR *name)
  13 : debug_ (debug)
  14 {
  15   ACE_TRACE ("ACE_Token_Collection::ACE_Token_Collection");
  16
  17   if (name == 0)
  18     name = ACE_TEXT ("no name");
  19
  20   ACE_OS::strsncpy (this->name_,
  21                     const_cast<ACE_TCHAR *> (name),
  22                     ACE_MAXTOKENNAMELEN);
  23 }
  24
  25 int
  26 ACE_Token_Collection::insert (ACE_Token_Proxy &new_token)
  27 {
  28   ACE_TRACE ("ACE_Token_Collection::insert");
  29
  30   TOKEN_NAME name (new_token.name ());
  31
  32   // Check if the new_proxy is already in the list.
  33   if (collection_.find (name) == 1)
  34     // One already exists, so fail.
  35     return -1;
  36
  37   // Clone the new token.
  38   ACE_Token_Proxy *temp = new_token.clone ();
  39
  40   if (collection_.bind (name, temp) == -1)
  41     ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("bind failed\n")), -1);
  42   return 0;
  43 }
  44
  45 int
  46 ACE_Token_Collection::extract (const ACE_TCHAR *token_name, ACE_Token_Proxy *&proxy)
  47 {
  48   ACE_TRACE ("ACE_Token_Collection::extract");
  49   TOKEN_NAME name (token_name);
  50   return collection_.unbind (token_name, proxy);
  51 }
  52
  53 ACE_Token_Proxy *
  54 ACE_Token_Collection::is_member (const ACE_TCHAR *token_name)
  55 {
  56   ACE_TRACE ("ACE_Token_Collection::is_member");
  57   TOKEN_NAME name (token_name);
  58   ACE_Token_Proxy *temp;
  59   // Get the token from the collection.
  60   return collection_.find (name, temp) == -1 ? 0 : temp;
  61 }
  62
  63 int
  64 ACE_Token_Collection::is_member (const ACE_Token_Proxy &token)
  65 {
  66   ACE_TRACE ("ACE_Token_Collection::is_member");
  67   TOKEN_NAME token_name (token.name ());
  68   return collection_.find (token_name) == 0;
  69 }
  70
  71 int
  72 ACE_Token_Collection::acquire (int notify,
  73                                void (*sleep_hook)(void *),
  74                                ACE_Synch_Options &options)
  75 {
  76   ACE_TRACE ("ACE_Token_Collection::acquire");
  77
  78   COLLECTION::ITERATOR iterator (collection_);
  79
  80   for (COLLECTION::ENTRY *temp = 0;
  81        iterator.next (temp) != 0;
  82        iterator.advance ())
  83     {
  84       if (debug_)
  85         ACELIB_DEBUG ((LM_DEBUG,
  86                     ACE_TEXT ("collection acquiring %s\n"),
  87                     temp->int_id_->name ()));
  88       if (temp->int_id_->acquire (notify,
  89                                   sleep_hook,
  90                                   options) == -1)
  91         {
  92           // Save/restore errno.
  93           ACE_Errno_Guard error (errno);
  94           this->release ();
  95           ACE_RETURN (-1);
  96         }
  97     }
  98
  99   return 0;
 100 }
 101
 102 int
 103 ACE_Token_Collection::acquire (const ACE_TCHAR *token_name,
 104                                int notify,
 105                                void (*sleep_hook)(void *),
 106                                ACE_Synch_Options &options)
 107 {
 108   ACE_TRACE ("ACE_Token_Collection::acquire");
 109   TOKEN_NAME name (token_name);
 110   ACE_Token_Proxy *temp;
 111   // Get the token from the collection.
 112   int result = collection_.find (name, temp);
 113   // did we find it?
 114   if (result == -1)
 115     return result;
 116   // perform the operation
 117   return temp->acquire (notify, sleep_hook, options);
 118 }
 119
 120
 121 int
 122 ACE_Token_Collection::tryacquire (const ACE_TCHAR *token_name,
 123                                   void (*sleep_hook)(void *))
 124 {
 125   ACE_TRACE ("ACE_Token_Collection::tryacquire");
 126   TOKEN_NAME name (token_name);
 127   ACE_Token_Proxy *temp;
 128   // Get the token from the collection.
 129   int result = collection_.find (name, temp);
 130   // did we find it?
 131   if (result == -1)
 132     return result;
 133
 134   // perform the operation
 135   return temp->tryacquire (sleep_hook);
 136 }
 137
 138 int
 139 ACE_Token_Collection::tryacquire (void (*sleep_hook)(void *))
 140 {
 141   ACE_TRACE ("ACE_Token_Collection::tryacquire");
 142
 143   COLLECTION::ITERATOR iterator (collection_);
 144
 145   for (COLLECTION::ENTRY *temp = 0;
 146        iterator.next (temp) != 0;
 147        iterator.advance ())
 148     {
 149       if (debug_)
 150         ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("collection acquiring %s\n"),
 151                     temp->int_id_->name ()));
 152       // We will fail if _any_ token is not free.
 153       if (temp->int_id_->tryacquire (sleep_hook) == -1)
 154         return -1;
 155     }
 156
 157   return 0;
 158 }
 159
 160 int
 161 ACE_Token_Collection::renew (int requeue_position,
 162                              ACE_Synch_Options &options)
 163 {
 164   ACE_TRACE ("ACE_Token_Collection::renew");
 165
 166   COLLECTION::ITERATOR iterator (collection_);
 167
 168   for (COLLECTION::ENTRY *temp = 0;
 169        iterator.next (temp) != 0;
 170        iterator.advance ())
 171     {
 172       if (debug_)
 173         ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("collection renewing %s\n"),
 174                     temp->int_id_->name ()));
 175       if (temp->int_id_->renew (requeue_position, options) == -1)
 176         return -1;
 177     }
 178
 179   return 0;
 180 }
 181
 182 int
 183 ACE_Token_Collection::renew (const ACE_TCHAR *token_name,
 184                              int requeue_position,
 185                              ACE_Synch_Options &options)
 186 {
 187   ACE_TRACE ("ACE_Token_Collection::renew");
 188   TOKEN_NAME name (token_name);
 189   ACE_Token_Proxy *temp;
 190
 191   // Get the token from the collection.
 192   int result = collection_.find (name, temp);
 193
 194   // Did we find it?
 195   if (result == -1)
 196     ACELIB_ERROR_RETURN ((LM_DEBUG, ACE_TEXT ("%p %s\n"),
 197                        ACE_TEXT ("not in collection "),
 198                        token_name), -1);
 199   // perform the operation
 200   return temp->renew (requeue_position, options);
 201 }
 202
 203 int
 204 ACE_Token_Collection::release (ACE_Synch_Options &)
 205
 206 {
 207   ACE_TRACE ("ACE_Token_Collection::release");
 208   COLLECTION::ITERATOR iterator (collection_);
 209
 210   for (COLLECTION::ENTRY *temp = 0;
 211        iterator.next (temp) != 0;
 212        iterator.advance ())
 213     {
 214       if (debug_)
 215         ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("collection releasing %s\n"),
 216                     temp->int_id_->name ()));
 217       temp->int_id_->release ();
 218     }
 219
 220   return 0;
 221 }
 222
 223 int
 224 ACE_Token_Collection::release (const ACE_TCHAR *token_name,
 225                                ACE_Synch_Options &options)
 226 {
 227   ACE_TRACE ("ACE_Token_Collection::release");
 228   TOKEN_NAME name (token_name);
 229   ACE_Token_Proxy *temp;
 230   // get the token from the collection
 231   int result = collection_.find (name, temp);
 232   // did we find it?
 233   if (result != 0)
 234     return result;
 235   // perform the operation
 236   return temp->release (options);
 237 }
 238
 239 ACE_Token_Collection::~ACE_Token_Collection ()
 240 {
 241   ACE_TRACE ("ACE_Token_Collection::~ACE_Token_Collection");
 242   COLLECTION::ITERATOR iterator (collection_);
 243
 244   for (COLLECTION::ENTRY *temp = 0;
 245        iterator.next (temp) != 0;
 246        iterator.advance ())
 247     {
 248       delete temp->int_id_;
 249       // The ext_id_'s delete themselves when the array of
 250       // COLLECTION::ENTRYs goes away.
 251     }
 252 }
 253
 254
 255 // This method doesn't mean anything for a collection.
 256 ACE_Token_Proxy *
 257 ACE_Token_Collection::clone () const
 258 {
 259   ACE_TRACE ("ACE_Token_Collection::clone");
 260   return (ACE_Token_Proxy *) 0;
 261 }
 262
 263 // This method doesn't mean anything for a collection.
 264 ACE_Tokens *
 265 ACE_Token_Collection::create_token (const ACE_TCHAR *)
 266 {
 267   ACE_TRACE ("ACE_Token_Collection::create_token");
 268   return (ACE_Tokens *) 0;
 269 }
 270
 271 void
 272 ACE_Token_Collection::dump () const
 273 {
 274 #if defined (ACE_HAS_DUMP)
 275   ACE_TRACE ("ACE_Token_Collection::dump");
 276   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 277   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Token_Collection::dump:\n")
 278               ACE_TEXT (" debug_ = %d\n"), debug_));
 279   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("collection_\n")));
 280   collection_.dump ();
 281   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("base:\n")));
 282   ACE_Token_Proxy::dump ();
 283   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 284 #endif /* ACE_HAS_DUMP */
 285 }
 286
 287 ACE_END_VERSIONED_NAMESPACE_DECL
 288
 289 #endif /* ACE_HAS_TOKENS_LIBRARY */