ACE/ace/Unbounded_Set_Ex.cpp

   1 #ifndef ACE_UNBOUNDED_SET_EX_CPP
   2 #define ACE_UNBOUNDED_SET_EX_CPP
   3
   4 #include "ace/Unbounded_Set.h"
   5 #include "ace/Malloc_Base.h"
   6 #include "ace/Log_Category.h"
   7
   8 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   9 # pragma once
  10 #endif /* ACE_LACKS_PRAGMA_ONCE */
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/Unbounded_Set_Ex.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex)
  19
  20 template <class T, class C> size_t
  21 ACE_Unbounded_Set_Ex<T, C>::size () const
  22 {
  23   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::size");
  24   return this->cur_size_;
  25 }
  26
  27 template <class T, class C> int
  28 ACE_Unbounded_Set_Ex<T, C>::insert_tail (const T &item)
  29 {
  30   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::insert_tail");
  31   NODE *temp = 0;
  32
  33   // Insert <item> into the old dummy node location.
  34   this->head_->item_ = item;
  35
  36   // Create a new dummy node.
  37   ACE_NEW_MALLOC_RETURN (temp,
  38                          static_cast<NODE*> (this->allocator_->malloc (sizeof (NODE))),
  39                          NODE (this->head_->next_),
  40                          -1);
  41   // Link this pointer into the list.
  42   this->head_->next_ = temp;
  43
  44   // Point the head to the new dummy node.
  45   this->head_ = temp;
  46
  47   ++this->cur_size_;
  48   return 0;
  49 }
  50
  51 template <class T, class C> void
  52 ACE_Unbounded_Set_Ex<T, C>::reset ()
  53 {
  54   ACE_TRACE ("reset");
  55
  56   this->delete_nodes ();
  57 }
  58
  59 template <class T, class C> void
  60 ACE_Unbounded_Set_Ex<T, C>::dump () const
  61 {
  62 #if defined (ACE_HAS_DUMP)
  63   ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::dump");
  64
  65   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  66   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nhead_ = %u"), this->head_));
  67   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nhead_->next_ = %u"), this->head_->next_));
  68   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\ncur_size_ = %d\n"), this->cur_size_));
  69
  70   T *item = 0;
  71 #if !defined (ACE_NLOGGING)
  72   size_t count = 1;
  73 #endif /* ! ACE_NLOGGING */
  74
  75   const_iterator const the_end = this->end ();
  76   for (const_iterator i (this->begin ());
  77        i != the_end;
  78        ++i)
  79     ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("count = %u\n"), count++));
  80
  81   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  82 #endif /* ACE_HAS_DUMP */
  83 }
  84
  85 template <class T, class C> void
  86 ACE_Unbounded_Set_Ex<T, C>::copy_nodes (const ACE_Unbounded_Set_Ex<T, C> &us)
  87 {
  88   for (NODE *curr = us.head_->next_;
  89        curr != us.head_;
  90        curr = curr->next_)
  91     this->insert_tail (curr->item_);
  92 }
  93
  94 template <class T, class C> void
  95 ACE_Unbounded_Set_Ex<T, C>::delete_nodes ()
  96 {
  97   NODE *curr = this->head_->next_;
  98
  99   // Keep looking until we've hit the dummy node.
 100
 101   while (curr != this->head_)
 102     {
 103       NODE *temp = curr;
 104       curr = curr->next_;
 105       ACE_DES_FREE_TEMPLATE2 (temp,
 106                              this->allocator_->free,
 107                              ACE_Node,
 108                              T, C);
 109       --this->cur_size_;
 110     }
 111
 112   // Reset the list to be a circular list with just a dummy node.
 113   this->head_->next_ = this->head_;
 114 }
 115
 116 template <class T, class C>
 117 ACE_Unbounded_Set_Ex<T, C>::~ACE_Unbounded_Set_Ex ()
 118 {
 119   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::~ACE_Unbounded_Set_Ex");
 120
 121   this->delete_nodes ();
 122
 123   // Delete the dummy node.
 124   ACE_DES_FREE_TEMPLATE2 (head_,
 125                          this->allocator_->free,
 126                          ACE_Node,
 127                          T, C);
 128   this->head_ = 0;
 129 }
 130
 131 template <class T, class C>
 132 ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex (ACE_Allocator *alloc)
 133   : head_ (0),
 134     cur_size_ (0),
 135     allocator_ (alloc)
 136 {
 137   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex");
 138
 139   if (this->allocator_ == 0)
 140     this->allocator_ = ACE_Allocator::instance ();
 141
 142   ACE_NEW_MALLOC (this->head_,
 143                   (NODE*) this->allocator_->malloc (sizeof (NODE)),
 144                   NODE);
 145   // Make the list circular by pointing it back to itself.
 146   this->head_->next_ = this->head_;
 147 }
 148
 149 template <class T, class C>
 150 ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex (const C &comp,
 151                                             ACE_Allocator *alloc)
 152   : head_ (0),
 153     cur_size_ (0),
 154     allocator_ (alloc),
 155     comp_ (comp)
 156 {
 157   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex");
 158
 159   if (this->allocator_ == 0)
 160     this->allocator_ = ACE_Allocator::instance ();
 161
 162   ACE_NEW_MALLOC (this->head_,
 163                   (NODE*) this->allocator_->malloc (sizeof (NODE)),
 164                   NODE);
 165   // Make the list circular by pointing it back to itself.
 166   this->head_->next_ = this->head_;
 167 }
 168
 169 template <class T, class C>
 170 ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex (const ACE_Unbounded_Set_Ex<T, C> &us)
 171   : head_ (0),
 172     cur_size_ (0),
 173     allocator_ (us.allocator_),
 174     comp_ (us.comp_)
 175 {
 176   ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::ACE_Unbounded_Set_Ex");
 177
 178   if (this->allocator_ == 0)
 179     this->allocator_ = ACE_Allocator::instance ();
 180
 181   ACE_NEW_MALLOC (this->head_,
 182                   (NODE*) this->allocator_->malloc (sizeof (NODE)),
 183                   NODE);
 184   this->head_->next_ = this->head_;
 185   this->copy_nodes (us);
 186 }
 187
 188 template <class T, class C> ACE_Unbounded_Set_Ex<T, C> &
 189 ACE_Unbounded_Set_Ex<T, C>::operator= (const ACE_Unbounded_Set_Ex<T, C> &us)
 190 {
 191   ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::operator=");
 192
 193   if (this != &us)
 194     {
 195       this->delete_nodes ();
 196       this->copy_nodes (us);
 197     }
 198
 199   return *this;
 200 }
 201
 202 template <class T, class C> int
 203 ACE_Unbounded_Set_Ex<T, C>::find (const T &item) const
 204 {
 205   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::find");
 206   const_iterator const the_end = this->end ();
 207   for (const_iterator i = this->begin (); i != the_end; ++i)
 208     if (this->comp_(*i, item))
 209       return 0;
 210
 211   return -1;
 212 }
 213
 214 template <class T, class C> int
 215 ACE_Unbounded_Set_Ex<T, C>::insert (const T &item)
 216 {
 217   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::insert");
 218   if (this->find (item) == 0)
 219     return 1;
 220   else
 221     return this->insert_tail (item);
 222 }
 223
 224 template <class T, class C> int
 225 ACE_Unbounded_Set_Ex<T, C>::remove (const T &item)
 226 {
 227   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::remove");
 228
 229   // Insert the item to be found into the dummy node.
 230   this->head_->item_ = item;
 231
 232   NODE *curr = this->head_;
 233
 234   while (!(this->comp_ (curr->next_->item_, item)))
 235     curr = curr->next_;
 236
 237   // reset the dummy node. This ensures reference counted items are
 238   // completely released. Without this, a reference can linger as
 239   // the dummy long after it was removed from the list.
 240   this->head_->item_ = T();
 241
 242   if (curr->next_ == this->head_)
 243     return -1; // Item was not found.
 244   else
 245     {
 246       NODE *temp = curr->next_;
 247       // Skip over the node that we're deleting.
 248       curr->next_ = temp->next_;
 249       --this->cur_size_;
 250       ACE_DES_FREE_TEMPLATE2 (temp,
 251                              this->allocator_->free,
 252                              ACE_Node,
 253                              T, C);
 254       return 0;
 255     }
 256 }
 257
 258 template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::iterator
 259 ACE_Unbounded_Set_Ex<T, C>::begin ()
 260 {
 261   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::begin");
 262   return iterator (*this);
 263 }
 264
 265 template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::iterator
 266 ACE_Unbounded_Set_Ex<T, C>::end ()
 267 {
 268   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::end");
 269   return iterator (*this, 1);
 270 }
 271
 272 template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::const_iterator
 273 ACE_Unbounded_Set_Ex<T, C>::begin () const
 274 {
 275   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::begin");
 276   return const_iterator (*this);
 277 }
 278
 279 template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::const_iterator
 280 ACE_Unbounded_Set_Ex<T, C>::end () const
 281 {
 282   // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::end");
 283   return const_iterator (*this, 1);
 284 }
 285
 286 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex_Iterator)
 287
 288 template <class T, class C> void
 289 ACE_Unbounded_Set_Ex_Iterator<T, C>::dump () const
 290 {
 291 #if defined (ACE_HAS_DUMP)
 292   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::dump");
 293 #endif /* ACE_HAS_DUMP */
 294 }
 295
 296 template <class T, class C>
 297 ACE_Unbounded_Set_Ex_Iterator<T, C>::ACE_Unbounded_Set_Ex_Iterator (
 298   ACE_Unbounded_Set_Ex<T, C> &s,
 299   bool end)
 300   : current_ (!end ? s.head_->next_ : s.head_ ),
 301     set_ (&s)
 302 {
 303   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::ACE_Unbounded_Set_Ex_Iterator");
 304 }
 305
 306 template <class T, class C> int
 307 ACE_Unbounded_Set_Ex_Iterator<T, C>::advance ()
 308 {
 309   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::advance");
 310   this->current_ = this->current_->next_;
 311   return this->current_ != this->set_->head_;
 312 }
 313
 314 template <class T, class C> int
 315 ACE_Unbounded_Set_Ex_Iterator<T, C>::first ()
 316 {
 317   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::first");
 318   this->current_ = this->set_->head_->next_;
 319   return this->current_ != this->set_->head_;
 320 }
 321
 322 template <class T, class C> int
 323 ACE_Unbounded_Set_Ex_Iterator<T, C>::done () const
 324 {
 325   ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::done");
 326
 327   return this->current_ == this->set_->head_;
 328 }
 329
 330 template <class T, class C> int
 331 ACE_Unbounded_Set_Ex_Iterator<T, C>::next (T *&item)
 332 {
 333   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::next");
 334   if (this->current_ == this->set_->head_)
 335     return 0;
 336   else
 337     {
 338       item = &this->current_->item_;
 339       return 1;
 340     }
 341 }
 342
 343 template <class T, class C> ACE_Unbounded_Set_Ex_Iterator<T, C>
 344 ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (int)
 345 {
 346   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (int)");
 347   ACE_Unbounded_Set_Ex_Iterator<T, C> retv (*this);
 348
 349   // postfix operator
 350
 351   this->advance ();
 352   return retv;
 353 }
 354
 355 template <class T, class C> ACE_Unbounded_Set_Ex_Iterator<T, C>&
 356 ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ ()
 357 {
 358   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ ()");
 359
 360   // prefix operator
 361
 362   this->advance ();
 363   return *this;
 364 }
 365
 366 template <class T, class C> T&
 367 ACE_Unbounded_Set_Ex_Iterator<T, C>::operator* ()
 368 {
 369   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator*");
 370   T *retv = 0;
 371
 372   int result = this->next (retv);
 373   ACE_ASSERT (result != 0);
 374   ACE_UNUSED_ARG (result);
 375
 376   return *retv;
 377 }
 378
 379 template <class T, class C> bool
 380 ACE_Unbounded_Set_Ex_Iterator<T, C>::operator== (const ACE_Unbounded_Set_Ex_Iterator<T, C> &rhs) const
 381 {
 382   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator==");
 383   return (this->set_ == rhs.set_ && this->current_ == rhs.current_);
 384 }
 385
 386 template <class T, class C> bool
 387 ACE_Unbounded_Set_Ex_Iterator<T, C>::operator!= (const ACE_Unbounded_Set_Ex_Iterator<T, C> &rhs) const
 388 {
 389   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator!=");
 390   return (this->set_ != rhs.set_ || this->current_ != rhs.current_);
 391 }
 392
 393 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex_Const_Iterator)
 394
 395 template <class T, class C> void
 396 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::dump () const
 397 {
 398 #if defined (ACE_HAS_DUMP)
 399   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::dump");
 400 #endif /* ACE_HAS_DUMP */
 401 }
 402
 403 template <class T, class C>
 404 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::ACE_Unbounded_Set_Ex_Const_Iterator (
 405   const ACE_Unbounded_Set_Ex<T, C> &s,
 406   bool end)
 407   : current_ (!end ? s.head_->next_ : s.head_ ),
 408     set_ (&s)
 409 {
 410   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::ACE_Unbounded_Set_Ex_Const_Iterator");
 411 }
 412
 413 template <class T, class C> int
 414 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance ()
 415 {
 416   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance");
 417   this->current_ = this->current_->next_;
 418   return this->current_ != this->set_->head_;
 419 }
 420
 421 template <class T, class C> int
 422 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first ()
 423 {
 424   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first");
 425   this->current_ = this->set_->head_->next_;
 426   return this->current_ != this->set_->head_;
 427 }
 428
 429 template <class T, class C> int
 430 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::done () const
 431 {
 432   ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::done");
 433
 434   return this->current_ == this->set_->head_;
 435 }
 436
 437 template <class T, class C> int
 438 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::next (T *&item)
 439 {
 440   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::next");
 441   if (this->current_ == this->set_->head_)
 442     return 0;
 443   else
 444     {
 445       item = &this->current_->item_;
 446       return 1;
 447     }
 448 }
 449
 450 template <class T, class C> ACE_Unbounded_Set_Ex_Const_Iterator<T, C>
 451 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (int)
 452 {
 453   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (int)");
 454   ACE_Unbounded_Set_Ex_Const_Iterator<T, C> retv (*this);
 455
 456   // postfix operator
 457
 458   this->advance ();
 459   return retv;
 460 }
 461
 462 template <class T, class C> ACE_Unbounded_Set_Ex_Const_Iterator<T, C>&
 463 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ ()
 464 {
 465   // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ ()");
 466
 467   // prefix operator
 468
 469   this->advance ();
 470   return *this;
 471 }
 472
 473 template <class T, class C> T&
 474 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator* ()
 475 {
 476   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator*");
 477   T *retv = 0;
 478
 479   int const result = this->next (retv);
 480   ACE_ASSERT (result != 0);
 481   ACE_UNUSED_ARG (result);
 482
 483   return *retv;
 484 }
 485
 486 template <class T, class C> bool
 487 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator== (const ACE_Unbounded_Set_Ex_Const_Iterator<T, C> &rhs) const
 488 {
 489   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator==");
 490   return (this->set_ == rhs.set_ && this->current_ == rhs.current_);
 491 }
 492
 493 template <class T, class C> bool
 494 ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator!= (const ACE_Unbounded_Set_Ex_Const_Iterator<T, C> &rhs) const
 495 {
 496   //ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator!=");
 497   return (this->set_ != rhs.set_ || this->current_ != rhs.current_);
 498 }
 499
 500 ACE_END_VERSIONED_NAMESPACE_DECL
 501
 502 #endif /* ACE_UNBOUNDED_SET_EX_CPP */