00001
00002
00003 #ifndef ACE_CONTAINERS_T_CPP
00004 #define ACE_CONTAINERS_T_CPP
00005
00006 #include "ace/Log_Msg.h"
00007 #include "ace/Malloc_Base.h"
00008 #include "ace/OS_Memory.h"
00009
00010 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00011 # pragma once
00012 #endif
00013
00014 #include "ace/Containers.h"
00015
00016 #if !defined (__ACE_INLINE__)
00017 #include "ace/Containers_T.inl"
00018 #endif
00019
00020 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00021
00022 ACE_ALLOC_HOOK_DEFINE(ACE_Bounded_Stack)
00023
00024 template <class T> void
00025 ACE_Bounded_Stack<T>::dump (void) const
00026 {
00027 #if defined (ACE_HAS_DUMP)
00028 ACE_TRACE ("ACE_Bounded_Stack<T>::dump");
00029 #endif
00030 }
00031
00032 template<class T>
00033 ACE_Bounded_Stack<T>::ACE_Bounded_Stack (size_t size)
00034 : size_ (size),
00035 top_ (0)
00036 {
00037 ACE_NEW (this->stack_,
00038 T[size]);
00039 ACE_TRACE ("ACE_Bounded_Stack<T>::ACE_Bounded_Stack");
00040 }
00041
00042 template<class T>
00043 ACE_Bounded_Stack<T>::ACE_Bounded_Stack (const ACE_Bounded_Stack<T> &s)
00044 : size_ (s.size_),
00045 top_ (s.top_)
00046 {
00047 ACE_NEW (this->stack_,
00048 T[s.size_]);
00049
00050 ACE_TRACE ("ACE_Bounded_Stack<T>::ACE_Bounded_Stack");
00051
00052 for (size_t i = 0; i < this->top_; i++)
00053 this->stack_[i] = s.stack_[i];
00054 }
00055
00056 template<class T> void
00057 ACE_Bounded_Stack<T>::operator= (const ACE_Bounded_Stack<T> &s)
00058 {
00059 ACE_TRACE ("ACE_Bounded_Stack<T>::operator=");
00060
00061 if (&s != this)
00062 {
00063 if (this->size_ < s.size_)
00064 {
00065 delete [] this->stack_;
00066 ACE_NEW (this->stack_,
00067 T[s.size_]);
00068 this->size_ = s.size_;
00069 }
00070 this->top_ = s.top_;
00071
00072 for (size_t i = 0; i < this->top_; i++)
00073 this->stack_[i] = s.stack_[i];
00074 }
00075 }
00076
00077 template<class T>
00078 ACE_Bounded_Stack<T>::~ACE_Bounded_Stack (void)
00079 {
00080 ACE_TRACE ("ACE_Bounded_Stack<T>::~ACE_Bounded_Stack");
00081 delete [] this->stack_;
00082 }
00083
00084
00085
00086 ACE_ALLOC_HOOK_DEFINE(ACE_Fixed_Stack)
00087
00088 template <class T, size_t ACE_SIZE> void
00089 ACE_Fixed_Stack<T, ACE_SIZE>::dump (void) const
00090 {
00091 #if defined (ACE_HAS_DUMP)
00092 ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::dump");
00093 #endif
00094 }
00095
00096 template<class T, size_t ACE_SIZE>
00097 ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack (void)
00098 : size_ (ACE_SIZE),
00099 top_ (0)
00100 {
00101 ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack");
00102 }
00103
00104 template<class T, size_t ACE_SIZE>
00105 ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack (const ACE_Fixed_Stack<T, ACE_SIZE> &s)
00106 : size_ (s.size_),
00107 top_ (s.top_)
00108 {
00109 ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack");
00110 for (size_t i = 0; i < this->top_; i++)
00111 this->stack_[i] = s.stack_[i];
00112 }
00113
00114 template<class T, size_t ACE_SIZE> void
00115 ACE_Fixed_Stack<T, ACE_SIZE>::operator= (const ACE_Fixed_Stack<T, ACE_SIZE> &s)
00116 {
00117 ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::operator=");
00118
00119 if (&s != this)
00120 {
00121 this->top_ = s.top_;
00122
00123 for (size_t i = 0; i < this->top_; i++)
00124 this->stack_[i] = s.stack_[i];
00125 }
00126 }
00127
00128 template<class T, size_t ACE_SIZE>
00129 ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack (void)
00130 {
00131 ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack");
00132 }
00133
00134
00135
00136 ACE_ALLOC_HOOK_DEFINE(ACE_Unbounded_Stack)
00137
00138 template <class T> void
00139 ACE_Unbounded_Stack<T>::dump (void) const
00140 {
00141 #if defined (ACE_HAS_DUMP)
00142
00143 #endif
00144 }
00145
00146 template<class T>
00147 ACE_Unbounded_Stack<T>::ACE_Unbounded_Stack (ACE_Allocator *alloc)
00148 : head_ (0),
00149 cur_size_ (0),
00150 allocator_ (alloc)
00151 {
00152
00153 if (this->allocator_ == 0)
00154 this->allocator_ = ACE_Allocator::instance ();
00155
00156 ACE_NEW_MALLOC (this->head_,
00157 (ACE_Node<T> *) this->allocator_->malloc (sizeof (ACE_Node<T>)),
00158 ACE_Node<T>);
00159 this->head_->next_ = this->head_;
00160 }
00161
00162 template<class T> void
00163 ACE_Unbounded_Stack<T>::delete_all_nodes (void)
00164 {
00165
00166
00167 while (this->is_empty () == 0)
00168 {
00169 ACE_Node<T> *temp = this->head_->next_;
00170 this->head_->next_ = temp->next_;
00171 ACE_DES_FREE_TEMPLATE (temp, this->allocator_->free,
00172 ACE_Node, <T>);
00173 }
00174
00175 this->cur_size_ = 0;
00176
00177 ACE_ASSERT (this->head_ == this->head_->next_
00178 && this->is_empty ());
00179 }
00180
00181 template<class T> void
00182 ACE_Unbounded_Stack<T>::copy_all_nodes (const ACE_Unbounded_Stack<T> &s)
00183 {
00184
00185
00186 ACE_ASSERT (this->head_ == this->head_->next_);
00187
00188 ACE_Node<T> *temp = this->head_;
00189
00190 for (ACE_Node<T> *s_temp = s.head_->next_;
00191 s_temp != s.head_;
00192 s_temp = s_temp->next_)
00193 {
00194 ACE_Node<T> *nptr = temp->next_;
00195 ACE_NEW_MALLOC (temp->next_,
00196 (ACE_Node<T> *) this->allocator_->malloc (sizeof (ACE_Node<T>)),
00197 ACE_Node<T> (s_temp->item_, nptr));
00198 temp = temp->next_;
00199 }
00200 this->cur_size_ = s.cur_size_;
00201 }
00202
00203 template<class T>
00204 ACE_Unbounded_Stack<T>::ACE_Unbounded_Stack (const ACE_Unbounded_Stack<T> &s)
00205 : head_ (0),
00206 cur_size_ (0),
00207 allocator_ (s.allocator_)
00208 {
00209 if (this->allocator_ == 0)
00210 this->allocator_ = ACE_Allocator::instance ();
00211
00212 ACE_NEW_MALLOC (this->head_,
00213 (ACE_Node<T> *) this->allocator_->malloc (sizeof (ACE_Node<T>)),
00214 ACE_Node<T>);
00215 this->head_->next_ = this->head_;
00216
00217
00218 this->copy_all_nodes (s);
00219 }
00220
00221 template<class T> void
00222 ACE_Unbounded_Stack<T>::operator= (const ACE_Unbounded_Stack<T> &s)
00223 {
00224
00225
00226 if (this != &s)
00227 {
00228 this->delete_all_nodes ();
00229 this->copy_all_nodes (s);
00230 }
00231 }
00232
00233 template<class T>
00234 ACE_Unbounded_Stack<T>::~ACE_Unbounded_Stack (void)
00235 {
00236
00237
00238 this->delete_all_nodes ();
00239 ACE_DES_FREE_TEMPLATE (head_,
00240 this->allocator_->free,
00241 ACE_Node,
00242 <T>);
00243 }
00244
00245 template<class T> int
00246 ACE_Unbounded_Stack<T>::push (const T &new_item)
00247 {
00248
00249
00250 ACE_Node<T> *temp = 0;
00251
00252 ACE_NEW_MALLOC_RETURN (temp,
00253 static_cast<ACE_Node<T> *> (this->allocator_->malloc (sizeof (ACE_Node<T>))),
00254 ACE_Node<T> (new_item, this->head_->next_),
00255 -1);
00256 this->head_->next_ = temp;
00257 ++this->cur_size_;
00258 return 0;
00259 }
00260
00261 template<class T> int
00262 ACE_Unbounded_Stack<T>::pop (T &item)
00263 {
00264
00265
00266 if (this->is_empty ())
00267 return -1;
00268 else
00269 {
00270 ACE_Node<T> *temp = this->head_->next_;
00271 item = temp->item_;
00272 this->head_->next_ = temp->next_;
00273
00274 ACE_DES_FREE_TEMPLATE (temp,
00275 this->allocator_->free,
00276 ACE_Node,
00277 <T>);
00278 --this->cur_size_;
00279 return 0;
00280 }
00281 }
00282
00283 template <class T> int
00284 ACE_Unbounded_Stack<T>::find (const T &item) const
00285 {
00286
00287
00288 this->head_->item_ = item;
00289
00290 ACE_Node<T> *temp = this->head_->next_;
00291
00292
00293 while (!(temp->item_ == item))
00294 temp = temp->next_;
00295
00296
00297
00298 return temp == this->head_ ? -1 : 0;
00299 }
00300
00301 template <class T> int
00302 ACE_Unbounded_Stack<T>::insert (const T &item)
00303 {
00304
00305
00306 if (this->find (item) == 0)
00307 return 1;
00308 else
00309 return this->push (item);
00310 }
00311
00312 template <class T> int
00313 ACE_Unbounded_Stack<T>::remove (const T &item)
00314 {
00315
00316
00317
00318 this->head_->item_ = item;
00319
00320 ACE_Node<T> *curr = this->head_;
00321
00322 while (!(curr->next_->item_ == item))
00323 curr = curr->next_;
00324
00325 if (curr->next_ == this->head_)
00326 return -1;
00327 else
00328 {
00329 ACE_Node<T> *temp = curr->next_;
00330
00331 curr->next_ = temp->next_;
00332 --this->cur_size_;
00333 ACE_DES_FREE_TEMPLATE (temp,
00334 this->allocator_->free,
00335 ACE_Node,
00336 <T>);
00337 return 0;
00338 }
00339 }
00340
00341
00342 ACE_ALLOC_HOOK_DEFINE(ACE_Double_Linked_List_Iterator_Base)
00343
00344 template <class T>
00345 ACE_Double_Linked_List_Iterator_Base<T>::ACE_Double_Linked_List_Iterator_Base (const ACE_Double_Linked_List<T> &dll)
00346 : current_ (0), dllist_ (&dll)
00347 {
00348
00349 }
00350
00351 template <class T>
00352 ACE_Double_Linked_List_Iterator_Base<T>::ACE_Double_Linked_List_Iterator_Base (const ACE_Double_Linked_List_Iterator_Base<T> &iter)
00353 : current_ (iter.current_),
00354 dllist_ (iter.dllist_)
00355 {
00356
00357 }
00358
00359
00360 template <class T> T *
00361 ACE_Double_Linked_List_Iterator_Base<T>::next (void) const
00362 {
00363 return this->not_done ();
00364 }
00365
00366 template <class T> int
00367 ACE_Double_Linked_List_Iterator_Base<T>::next (T *&ptr) const
00368 {
00369 ptr = this->not_done ();
00370 return ptr ? 1 : 0;
00371 }
00372
00373
00374 template <class T> int
00375 ACE_Double_Linked_List_Iterator_Base<T>::done (void) const
00376 {
00377 return this->not_done () ? 0 : 1;
00378 }
00379
00380 template <class T> T &
00381 ACE_Double_Linked_List_Iterator_Base<T>::operator* (void) const
00382 {
00383 return *(this->not_done ());
00384 }
00385
00386
00387
00388 template <class T> void
00389 ACE_Double_Linked_List_Iterator_Base<T>::reset (ACE_Double_Linked_List<T> &dll)
00390 {
00391 current_ = 0;
00392 dllist_ = &dll;
00393 }
00394
00395 template <class T> int
00396 ACE_Double_Linked_List_Iterator_Base<T>::go_head (void)
00397 {
00398 this->current_ = static_cast<T*> (dllist_->head_->next_);
00399 return this->current_ ? 1 : 0;
00400 }
00401
00402 template <class T> int
00403 ACE_Double_Linked_List_Iterator_Base<T>::go_tail (void)
00404 {
00405 this->current_ = static_cast<T*> (dllist_->head_->prev_);
00406 return this->current_ ? 1 : 0;
00407 }
00408
00409 template <class T> T *
00410 ACE_Double_Linked_List_Iterator_Base<T>::not_done (void) const
00411 {
00412 if (this->current_ != this->dllist_->head_)
00413 return this->current_;
00414 else
00415 return 0;
00416 }
00417
00418 template <class T> T *
00419 ACE_Double_Linked_List_Iterator_Base<T>::do_advance (void)
00420 {
00421 if (this->not_done ())
00422 {
00423 this->current_ = static_cast<T*> (this->current_->next_);
00424 return this->not_done ();
00425 }
00426 else
00427 return 0;
00428 }
00429
00430 template <class T> T *
00431 ACE_Double_Linked_List_Iterator_Base<T>::do_retreat (void)
00432 {
00433 if (this->not_done ())
00434 {
00435 this->current_ = static_cast<T*> (this->current_->prev_);
00436 return this->not_done ();
00437 }
00438 else
00439 return 0;
00440 }
00441
00442 template <class T> void
00443 ACE_Double_Linked_List_Iterator_Base<T>::dump_i (void) const
00444 {
00445 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00446 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("current_ = %x"), this->current_));
00447 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00448 }
00449
00450
00451 ACE_ALLOC_HOOK_DEFINE(ACE_Double_Linked_List_Iterator)
00452
00453 template <class T>
00454 ACE_Double_Linked_List_Iterator<T>::ACE_Double_Linked_List_Iterator (const ACE_Double_Linked_List<T> &dll)
00455 : ACE_Double_Linked_List_Iterator_Base <T> (dll)
00456 {
00457 this->current_ = static_cast<T*> (dll.head_->next_);
00458
00459
00460 }
00461
00462 template <class T> void
00463 ACE_Double_Linked_List_Iterator<T>::reset (ACE_Double_Linked_List<T> &dll)
00464 {
00465 this->ACE_Double_Linked_List_Iterator_Base <T>::reset (dll);
00466 this->current_ = static_cast<T*> (dll.head_->next_);
00467
00468
00469 }
00470
00471 template <class T> int
00472 ACE_Double_Linked_List_Iterator<T>::first (void)
00473 {
00474 return this->go_head ();
00475 }
00476
00477 template <class T> int
00478 ACE_Double_Linked_List_Iterator<T>::advance (void)
00479 {
00480 return this->do_advance () ? 1 : 0;
00481 }
00482
00483 template <class T> T*
00484 ACE_Double_Linked_List_Iterator<T>::advance_and_remove (bool dont_remove)
00485 {
00486 T* item = 0;
00487 if (dont_remove)
00488 this->do_advance ();
00489 else
00490 {
00491 item = this->next ();
00492 this->do_advance ();
00493
00494 ACE_Double_Linked_List<T> *dllist =
00495 const_cast<ACE_Double_Linked_List<T> *> (this->dllist_);
00496 dllist->remove (item);
00497 }
00498 return item;
00499 }
00500
00501 template <class T> void
00502 ACE_Double_Linked_List_Iterator<T>::dump (void) const
00503 {
00504 #if defined (ACE_HAS_DUMP)
00505 this->dump_i ();
00506 #endif
00507 }
00508
00509
00510
00511 template <class T>
00512 ACE_Double_Linked_List_Iterator<T> &
00513 ACE_Double_Linked_List_Iterator<T>::operator++ (void)
00514 {
00515 this->do_advance ();
00516 return *this;
00517 }
00518
00519
00520
00521
00522 template <class T>
00523 ACE_Double_Linked_List_Iterator<T>
00524 ACE_Double_Linked_List_Iterator<T>::operator++ (int)
00525 {
00526 ACE_Double_Linked_List_Iterator<T> retv (*this);
00527 this->do_advance ();
00528 return retv;
00529 }
00530
00531
00532
00533
00534 template <class T>
00535 ACE_Double_Linked_List_Iterator<T> &
00536 ACE_Double_Linked_List_Iterator<T>::operator-- (void)
00537 {
00538 this->do_retreat ();
00539 return *this;
00540 }
00541
00542
00543
00544
00545 template <class T>
00546 ACE_Double_Linked_List_Iterator<T>
00547 ACE_Double_Linked_List_Iterator<T>::operator-- (int)
00548 {
00549 ACE_Double_Linked_List_Iterator<T> retv (*this);
00550 this->do_retreat ();
00551 return retv;
00552 }
00553
00554
00555
00556 ACE_ALLOC_HOOK_DEFINE(ACE_Double_Linked_List_Reverse_Iterator)
00557
00558 template <class T>
00559 ACE_Double_Linked_List_Reverse_Iterator<T>::ACE_Double_Linked_List_Reverse_Iterator (ACE_Double_Linked_List<T> &dll)
00560 : ACE_Double_Linked_List_Iterator_Base <T> (dll)
00561 {
00562 this->current_ = static_cast<T*> (dll.head_->prev_);
00563
00564
00565 }
00566
00567 template <class T> void
00568 ACE_Double_Linked_List_Reverse_Iterator<T>::reset (ACE_Double_Linked_List<T> &dll)
00569 {
00570 this->ACE_Double_Linked_List_Iterator_Base <T>::reset (dll);
00571 this->current_ = static_cast<T*> (dll.head_->prev_);
00572
00573
00574 }
00575
00576 template <class T> int
00577 ACE_Double_Linked_List_Reverse_Iterator<T>::first (void)
00578 {
00579 return this->go_tail ();
00580 }
00581
00582 template <class T> int
00583 ACE_Double_Linked_List_Reverse_Iterator<T>::advance (void)
00584 {
00585 return this->do_retreat () ? 1 : 0;
00586 }
00587
00588 template <class T> T*
00589 ACE_Double_Linked_List_Reverse_Iterator<T>::advance_and_remove (bool dont_remove)
00590 {
00591 T* item = 0;
00592 if (dont_remove)
00593 {
00594 this->do_retreat ();
00595 }
00596 else
00597 {
00598 item = this->next ();
00599 this->do_retreat ();
00600
00601 ACE_Double_Linked_List<T> *dllist =
00602 const_cast<ACE_Double_Linked_List<T> *> (this->dllist_);
00603 dllist->remove (item);
00604 }
00605 return item;
00606 }
00607
00608 template <class T> void
00609 ACE_Double_Linked_List_Reverse_Iterator<T>::dump (void) const
00610 {
00611 #if defined (ACE_HAS_DUMP)
00612 this->dump_i ();
00613 #endif
00614 }
00615
00616
00617
00618 template <class T>
00619 ACE_Double_Linked_List_Reverse_Iterator<T> &
00620 ACE_Double_Linked_List_Reverse_Iterator<T>::operator++ (void)
00621 {
00622 this->do_retreat ();
00623 return *this;
00624 }
00625
00626
00627
00628
00629 template <class T>
00630 ACE_Double_Linked_List_Reverse_Iterator<T>
00631 ACE_Double_Linked_List_Reverse_Iterator<T>::operator++ (int)
00632 {
00633 ACE_Double_Linked_List_Reverse_Iterator<T> retv (*this);
00634 this->do_retreat ();
00635 return retv;
00636 }
00637
00638
00639
00640
00641 template <class T>
00642 ACE_Double_Linked_List_Reverse_Iterator<T> &
00643 ACE_Double_Linked_List_Reverse_Iterator<T>::operator-- (void)
00644 {
00645 this->do_advance ();
00646 return *this;
00647 }
00648
00649
00650
00651
00652 template <class T>
00653 ACE_Double_Linked_List_Reverse_Iterator<T>
00654 ACE_Double_Linked_List_Reverse_Iterator<T>::operator-- (int)
00655 {
00656 ACE_Double_Linked_List_Reverse_Iterator<T> retv (*this);
00657 this->do_advance ();
00658 return retv;
00659 }
00660
00661
00662 ACE_ALLOC_HOOK_DEFINE(ACE_Double_Linked_List)
00663
00664 template <class T>
00665 ACE_Double_Linked_List<T>:: ACE_Double_Linked_List (ACE_Allocator *alloc)
00666 : size_ (0), allocator_ (alloc)
00667 {
00668 if (this->allocator_ == 0)
00669 this->allocator_ = ACE_Allocator::instance ();
00670
00671 ACE_NEW_MALLOC (this->head_,
00672 (T *) this->allocator_->malloc (sizeof (T)),
00673 T);
00674 this->init_head ();
00675 }
00676
00677 template <class T>
00678 ACE_Double_Linked_List<T>::ACE_Double_Linked_List (const ACE_Double_Linked_List<T> &cx)
00679 : allocator_ (cx.allocator_)
00680 {
00681 if (this->allocator_ == 0)
00682 this->allocator_ = ACE_Allocator::instance ();
00683
00684 ACE_NEW_MALLOC (this->head_,
00685 (T *) this->allocator_->malloc (sizeof (T)),
00686 T);
00687 this->init_head ();
00688 this->copy_nodes (cx);
00689 this->size_ = cx.size_;
00690 }
00691
00692 template <class T> void
00693 ACE_Double_Linked_List<T>::operator= (const ACE_Double_Linked_List<T> &cx)
00694 {
00695 if (this != &cx)
00696 {
00697 this->delete_nodes ();
00698 this->copy_nodes (cx);
00699 }
00700 }
00701
00702 template <class T>
00703 ACE_Double_Linked_List<T>::~ACE_Double_Linked_List (void)
00704 {
00705 this->delete_nodes ();
00706
00707 ACE_DES_FREE (head_,
00708 this->allocator_->free,
00709 T);
00710
00711 this->head_ = 0;
00712 }
00713
00714 template <class T> int
00715 ACE_Double_Linked_List<T>::is_empty (void) const
00716 {
00717 return this->size () ? 0 : 1;
00718 }
00719
00720 template <class T> int
00721 ACE_Double_Linked_List<T>::is_full (void) const
00722 {
00723 return 0;
00724 }
00725
00726 template <class T> T *
00727 ACE_Double_Linked_List<T>::insert_tail (T *new_item)
00728 {
00729
00730 this->insert_element (new_item, 1);
00731 return new_item;
00732 }
00733
00734 template <class T> T *
00735 ACE_Double_Linked_List<T>::insert_head (T *new_item)
00736 {
00737 this->insert_element (new_item);
00738 return new_item;
00739 }
00740
00741 template <class T> T *
00742 ACE_Double_Linked_List<T>::delete_head (void)
00743 {
00744 if (this->is_empty ())
00745 return 0;
00746
00747 T *temp = static_cast<T *> (this->head_->next_);
00748
00749 this->remove_element (temp);
00750 return temp;
00751 }
00752
00753 template <class T> T *
00754 ACE_Double_Linked_List<T>::delete_tail (void)
00755 {
00756 if (this->is_empty ())
00757 return 0;
00758
00759 T *temp = static_cast <T *> (this->head_->prev_);
00760
00761 this->remove_element (temp);
00762 return temp;
00763 }
00764
00765 template <class T> void
00766 ACE_Double_Linked_List<T>::reset (void)
00767 {
00768 this->delete_nodes ();
00769 }
00770
00771 template <class T> int
00772 ACE_Double_Linked_List<T>::get (T *&item, size_t slot)
00773 {
00774 ACE_Double_Linked_List_Iterator<T> iter (*this);
00775
00776 for (size_t i = 0;
00777 i < slot && !iter.done ();
00778 i++)
00779 iter.advance ();
00780
00781 item = iter.next ();
00782 return item ? 0 : -1;
00783 }
00784
00785 template <class T> size_t
00786 ACE_Double_Linked_List<T>::size (void) const
00787 {
00788 return this->size_;
00789 }
00790
00791 template <class T> void
00792 ACE_Double_Linked_List<T>::dump (void) const
00793 {
00794 #if defined (ACE_HAS_DUMP)
00795
00796 #endif
00797 }
00798
00799 #if 0
00800 template <class T> T *
00801 ACE_Double_Linked_List<T>::find (const T &item)
00802 {
00803 for (ACE_Double_Linked_List_Iterator<T> iter (*this);
00804 !iter.done ();
00805 iter.advance ())
00806 {
00807 T *temp = iter.next ();
00808
00809 if (*temp == item)
00810 return temp;
00811 }
00812
00813 return 0;
00814 }
00815
00816 template <class T> int
00817 ACE_Double_Linked_List<T>::remove (const T &item)
00818 {
00819 T *temp = this->find (item);
00820
00821 if (temp != 0)
00822 return this->remove (temp);
00823 else
00824 return -1;
00825 }
00826 #endif
00827
00828 template <class T> int
00829 ACE_Double_Linked_List<T>::remove (T *n)
00830 {
00831 return this->remove_element (n);
00832 }
00833
00834 template <class T> void
00835 ACE_Double_Linked_List<T>::delete_nodes (void)
00836 {
00837 while (! this->is_empty ())
00838 {
00839 T * temp = static_cast<T*> (this->head_->next_);
00840 this->remove_element (temp);
00841 ACE_DES_FREE (temp,
00842 this->allocator_->free,
00843 T);
00844 }
00845 }
00846
00847 template <class T> void
00848 ACE_Double_Linked_List<T>::copy_nodes (const ACE_Double_Linked_List<T> &c)
00849 {
00850 for (ACE_Double_Linked_List_Iterator<T> iter (c);
00851 !iter.done ();
00852 iter.advance ())
00853 {
00854 T* temp = 0;
00855 ACE_NEW_MALLOC (temp,
00856 (T *)this->allocator_->malloc (sizeof (T)),
00857 T (*iter.next ()));
00858 this->insert_tail (temp);
00859 }
00860 }
00861
00862 template <class T> void
00863 ACE_Double_Linked_List<T>::init_head (void)
00864 {
00865 this->head_->next_ = this->head_;
00866 this->head_->prev_ = this->head_;
00867 }
00868
00869 template <class T> int
00870 ACE_Double_Linked_List<T>::insert_element (T *new_item,
00871 int before,
00872 T *old_item)
00873 {
00874 if (old_item == 0)
00875 old_item = this->head_;
00876
00877 if (before)
00878 old_item = static_cast<T *> (old_item->prev_);
00879
00880 new_item->next_ = old_item->next_;
00881 new_item->next_->prev_ = new_item;
00882 new_item->prev_ = old_item;
00883 old_item->next_ = new_item;
00884 ++this->size_;
00885 return 0;
00886 }
00887
00888 template <class T> int
00889 ACE_Double_Linked_List<T>::remove_element (T *item)
00890 {
00891
00892
00893
00894 if (item == this->head_ || item->next_ == 0
00895 || item->prev_ == 0 || this->size () == 0)
00896 return -1;
00897
00898 item->prev_->next_ = item->next_;
00899 item->next_->prev_ = item->prev_;
00900 item->next_ = item->prev_ = 0;
00901 --this->size_;
00902 return 0;
00903 }
00904
00905
00906 ACE_ALLOC_HOOK_DEFINE(ACE_Fixed_Set)
00907
00908 template <class T, size_t ACE_SIZE> size_t
00909 ACE_Fixed_Set<T, ACE_SIZE>::size (void) const
00910 {
00911 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::size");
00912 return this->cur_size_;
00913 }
00914
00915 template <class T, size_t ACE_SIZE> void
00916 ACE_Fixed_Set<T, ACE_SIZE>::dump (void) const
00917 {
00918 #if defined (ACE_HAS_DUMP)
00919 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::dump");
00920 #endif
00921 }
00922
00923 template <class T, size_t ACE_SIZE>
00924 ACE_Fixed_Set<T, ACE_SIZE>::~ACE_Fixed_Set (void)
00925 {
00926 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::~ACE_Fixed_Set");
00927 this->cur_size_ = 0;
00928 }
00929
00930 template <class T, size_t ACE_SIZE>
00931 ACE_Fixed_Set<T, ACE_SIZE>::ACE_Fixed_Set (const ACE_Fixed_Set<T, ACE_SIZE> &fs)
00932 : cur_size_ (fs.cur_size_)
00933 {
00934 ACE_TRACE ("ACE_Fixed_Set<T>::ACE_Fixed_Set");
00935
00936 for (size_t i = 0, j = 0; i < fs.max_size_ && j < this->cur_size_; ++i)
00937 if (fs.search_structure_[i].is_free_ == 0)
00938 this->search_structure_[j++] = fs.search_structure_[i];
00939 }
00940
00941 template <class T, size_t ACE_SIZE> void
00942 ACE_Fixed_Set<T, ACE_SIZE>::operator= (const ACE_Fixed_Set<T, ACE_SIZE> &fs)
00943 {
00944 ACE_TRACE ("ACE_Fixed_Set<T>::operator=");
00945
00946 if (this != &fs)
00947 {
00948 this->cur_size_ = fs.cur_size_;
00949
00950 for (size_t i = 0, j = 0; i < fs.max_size_ && j < this->cur_size_; ++i)
00951 if (fs.search_structure_[i].is_free_ == 0)
00952 this->search_structure_[j++] = fs.search_structure_[i];
00953 }
00954 }
00955
00956 template <class T, size_t ACE_SIZE>
00957 ACE_Fixed_Set<T, ACE_SIZE>::ACE_Fixed_Set (void)
00958 : cur_size_ (0),
00959 max_size_ (ACE_SIZE)
00960 {
00961 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::ACE_Fixed_Set");
00962 for (size_t i = 0; i < this->max_size_; i++)
00963 this->search_structure_[i].is_free_ = 1;
00964 }
00965
00966 template <class T, size_t ACE_SIZE> int
00967 ACE_Fixed_Set<T, ACE_SIZE>::find (const T &item) const
00968 {
00969 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::find");
00970
00971 for (size_t i = 0, j = 0; i < this->max_size_ && j < this->cur_size_; ++i)
00972 if (this->search_structure_[i].is_free_ == 0)
00973 {
00974 if (this->search_structure_[i].item_ == item)
00975 return 0;
00976 ++j;
00977 }
00978
00979 return -1;
00980 }
00981
00982 template <class T, size_t ACE_SIZE> int
00983 ACE_Fixed_Set<T, ACE_SIZE>::insert (const T &item)
00984 {
00985 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::insert");
00986 ssize_t first_free = -1;
00987 size_t i;
00988
00989 for (i = 0;
00990 i < this->max_size_ && first_free == -1;
00991 ++i)
00992
00993
00994
00995 if (this->search_structure_[i].is_free_ == 0)
00996 {
00997 if (this->search_structure_[i].item_ == item)
00998 return 1;
00999 }
01000 else
01001 first_free = static_cast<ssize_t> (i);
01002
01003
01004
01005 if (first_free > -1)
01006 {
01007 this->search_structure_[first_free].item_ = item;
01008 this->search_structure_[first_free].is_free_ = 0;
01009 this->cur_size_++;
01010 return 0;
01011 }
01012 else
01013 {
01014 errno = ENOMEM;
01015 return -1;
01016 }
01017 }
01018
01019 template <class T, size_t ACE_SIZE> int
01020 ACE_Fixed_Set<T, ACE_SIZE>::remove (const T &item)
01021 {
01022 ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::remove");
01023
01024 for (size_t i = 0, j = 0;
01025 i < this->max_size_ && j < this->cur_size_;
01026 ++i)
01027 if (this->search_structure_[i].is_free_ == 0)
01028 {
01029 if (this->search_structure_[i].item_ == item)
01030 {
01031
01032 this->search_structure_[i].is_free_ = 1;
01033
01034 --this->cur_size_;
01035 return 0;
01036 }
01037 else
01038 ++j;
01039 }
01040
01041 return -1;
01042 }
01043
01044
01045 ACE_ALLOC_HOOK_DEFINE(ACE_Fixed_Set_Iterator_Base)
01046
01047 template <class T, size_t ACE_SIZE> void
01048 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::dump_i (void) const
01049 {
01050 #if defined (ACE_HAS_DUMP)
01051 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::dump_i");
01052 #endif
01053 }
01054
01055 template <class T, size_t ACE_SIZE>
01056 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::ACE_Fixed_Set_Iterator_Base (ACE_Fixed_Set<T, ACE_SIZE> &s)
01057 : s_ (s),
01058 next_ (-1),
01059 iterated_items_ (0)
01060 {
01061 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::ACE_Fixed_Set_Iterator_Base");
01062 this->advance ();
01063 }
01064
01065 template <class T, size_t ACE_SIZE> int
01066 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance (void)
01067 {
01068 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance");
01069
01070 if (this->iterated_items_ < this->s_.cur_size_)
01071 {
01072 for (++this->next_;
01073 static_cast<size_t> (this->next_) < this->s_.max_size_;
01074 ++this->next_)
01075 if (this->s_.search_structure_[this->next_].is_free_ == 0)
01076 {
01077 ++this->iterated_items_;
01078 return 1;
01079 }
01080 }
01081 else
01082 ++this->next_;
01083
01084 return 0;
01085 }
01086
01087 template <class T, size_t ACE_SIZE> int
01088 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first (void)
01089 {
01090 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first");
01091
01092 next_ = -1;
01093 iterated_items_ = 0;
01094 return this->advance ();
01095 }
01096
01097 template <class T, size_t ACE_SIZE> int
01098 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::done (void) const
01099 {
01100 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::done");
01101
01102 return ! (this->iterated_items_ < this->s_.cur_size_);
01103 }
01104
01105 template <class T, size_t ACE_SIZE> int
01106 ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::next_i (T *&item)
01107 {
01108 ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::next_i");
01109
01110 if (static_cast<size_t> (this->next_) < this->s_.max_size_)
01111 do
01112 {
01113 if (this->s_.search_structure_[this->next_].is_free_ == 0)
01114 {
01115 item = &this->s_.search_structure_[this->next_].item_;
01116 this->advance ();
01117 return 1;
01118 }
01119 }
01120 while (this->advance () == 1);
01121
01122 return 0;
01123 }
01124
01125
01126 ACE_ALLOC_HOOK_DEFINE(ACE_Fixed_Set_Iterator)
01127
01128 template <class T, size_t ACE_SIZE> void
01129 ACE_Fixed_Set_Iterator<T, ACE_SIZE>::dump (void) const
01130 {
01131 #if defined (ACE_HAS_DUMP)
01132 this->dump_i ();
01133 #endif
01134 }
01135
01136 template <class T, size_t ACE_SIZE>
01137 ACE_Fixed_Set_Iterator<T, ACE_SIZE>::ACE_Fixed_Set_Iterator (ACE_Fixed_Set<T, ACE_SIZE> &s)
01138 : ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE> (s)
01139 {
01140 ACE_TRACE ("ACE_Fixed_Set_Iterator<T, ACE_SIZE>::ACE_Fixed_Set_Iterator");
01141 }
01142
01143 template <class T, size_t ACE_SIZE> int
01144 ACE_Fixed_Set_Iterator<T, ACE_SIZE>::next (T *&item)
01145 {
01146 ACE_TRACE ("ACE_Fixed_Set_Iterator<T, ACE_SIZE>::next");
01147 return this->next_i (item);
01148 }
01149
01150 template <class T, size_t ACE_SIZE> int
01151 ACE_Fixed_Set_Iterator<T, ACE_SIZE>::remove (T *&item)
01152 {
01153 ACE_TRACE ("ACE_Fixed_Set_Iterator<T, ACE_SIZE>::remove");
01154
01155 if (this->s_.search_structure_[this->next_].is_free_ == 0)
01156 {
01157 item = &this->s_.search_structure_[this->next_].item_;
01158 this->s_.remove (*item);
01159 --(this->iterated_items_);
01160 return 1;
01161 }
01162
01163 return 0;
01164 }
01165
01166 template <class T, size_t ACE_SIZE> T&
01167 ACE_Fixed_Set_Iterator<T, ACE_SIZE>::operator* (void)
01168 {
01169 T *retv = 0;
01170
01171 if (this->s_.search_structure_[this->next_].is_free_ == 0)
01172 retv = &this->s_.search_structure_[this->next_].item_;
01173
01174 ACE_ASSERT (retv != 0);
01175
01176 return *retv;
01177 }
01178
01179
01180 ACE_ALLOC_HOOK_DEFINE(ACE_Fixed_Set_Const_Iterator)
01181
01182 template <class T, size_t ACE_SIZE> void
01183 ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::dump (void) const
01184 {
01185 #if defined (ACE_HAS_DUMP)
01186 this->dump_i ();
01187 #endif
01188 }
01189
01190 template <class T, size_t ACE_SIZE>
01191 ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::ACE_Fixed_Set_Const_Iterator (const ACE_Fixed_Set<T, ACE_SIZE> &s)
01192 : ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE> (s)
01193 {
01194 ACE_TRACE ("ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::ACE_Fixed_Set_Const_Iterator");
01195 }
01196
01197 template <class T, size_t ACE_SIZE> int
01198 ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::next (const T *&item)
01199 {
01200 ACE_TRACE ("ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::next");
01201
01202 return this->next_i (item);
01203 }
01204
01205 template <class T, size_t ACE_SIZE> const T&
01206 ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::operator* (void) const
01207 {
01208 const T *retv = 0;
01209
01210 if (this->s_.search_structure_[this->next_].is_free_ == 0)
01211 retv = &this->s_.search_structure_[this->next_].item_;
01212
01213 ACE_ASSERT (retv != 0);
01214
01215 return *retv;
01216 }
01217
01218
01219 ACE_ALLOC_HOOK_DEFINE(ACE_Bounded_Set)
01220
01221 template <class T> void
01222 ACE_Bounded_Set<T>::dump (void) const
01223 {
01224 #if defined (ACE_HAS_DUMP)
01225 ACE_TRACE ("ACE_Bounded_Set<T>::dump");
01226 #endif
01227 }
01228
01229 template <class T>
01230 ACE_Bounded_Set<T>::~ACE_Bounded_Set (void)
01231 {
01232 ACE_TRACE ("ACE_Bounded_Set<T>::~ACE_Bounded_Set");
01233 delete [] this->search_structure_;
01234 }
01235
01236 template <class T>
01237 ACE_Bounded_Set<T>::ACE_Bounded_Set (void)
01238 : cur_size_ (0),
01239 max_size_ (static_cast<size_t> (ACE_Bounded_Set<T>::DEFAULT_SIZE))
01240 {
01241 ACE_TRACE ("ACE_Bounded_Set<T>::ACE_Bounded_Set");
01242
01243 ACE_NEW (this->search_structure_,
01244 typename ACE_Bounded_Set<T>::Search_Structure[this->max_size_]);
01245
01246 for (size_t i = 0; i < this->max_size_; ++i)
01247 this->search_structure_[i].is_free_ = 1;
01248 }
01249
01250 template <class T> size_t
01251 ACE_Bounded_Set<T>::size (void) const
01252 {
01253 ACE_TRACE ("ACE_Bounded_Set<T>::size");
01254 return this->cur_size_;
01255 }
01256
01257 template <class T>
01258 ACE_Bounded_Set<T>::ACE_Bounded_Set (const ACE_Bounded_Set<T> &bs)
01259 : cur_size_ (bs.cur_size_),
01260 max_size_ (bs.max_size_)
01261 {
01262 ACE_TRACE ("ACE_Bounded_Set<T>::ACE_Bounded_Set");
01263
01264 ACE_NEW (this->search_structure_,
01265 typename ACE_Bounded_Set<T>::Search_Structure[this->max_size_]);
01266
01267 for (size_t i = 0; i < this->cur_size_; i++)
01268 this->search_structure_[i] = bs.search_structure_[i];
01269 }
01270
01271 template <class T> void
01272 ACE_Bounded_Set<T>::operator= (const ACE_Bounded_Set<T> &bs)
01273 {
01274 ACE_TRACE ("ACE_Bounded_Set<T>::operator=");
01275
01276 if (this != &bs)
01277 {
01278 if (this->max_size_ < bs.cur_size_)
01279 {
01280 delete [] this->search_structure_;
01281 ACE_NEW (this->search_structure_,
01282 typename ACE_Bounded_Set<T>::Search_Structure[bs.cur_size_]);
01283 this->max_size_ = bs.cur_size_;
01284 }
01285
01286 this->cur_size_ = bs.cur_size_;
01287
01288 for (size_t i = 0; i < this->cur_size_; i++)
01289 this->search_structure_[i] = bs.search_structure_[i];
01290 }
01291 }
01292
01293 template <class T>
01294 ACE_Bounded_Set<T>::ACE_Bounded_Set (size_t size)
01295 : cur_size_ (0),
01296 max_size_ (size)
01297 {
01298 ACE_TRACE ("ACE_Bounded_Set<T>::ACE_Bounded_Set");
01299 ACE_NEW (this->search_structure_,
01300 typename ACE_Bounded_Set<T>::Search_Structure[size]);
01301
01302 for (size_t i = 0; i < this->max_size_; i++)
01303 this->search_structure_[i].is_free_ = 1;
01304 }
01305
01306 template <class T> int
01307 ACE_Bounded_Set<T>::find (const T &item) const
01308 {
01309 ACE_TRACE ("ACE_Bounded_Set<T>::find");
01310
01311 for (size_t i = 0; i < this->cur_size_; i++)
01312 if (this->search_structure_[i].item_ == item
01313 && this->search_structure_[i].is_free_ == 0)
01314 return 0;
01315
01316 return -1;
01317 }
01318
01319 template <class T> int
01320 ACE_Bounded_Set<T>::insert (const T &item)
01321 {
01322 ACE_TRACE ("ACE_Bounded_Set<T>::insert");
01323 int first_free = -1;
01324 size_t i;
01325
01326 for (i = 0; i < this->cur_size_; i++)
01327
01328
01329 if (this->search_structure_[i].item_ == item
01330 && this->search_structure_[i].is_free_ == 0)
01331 return 1;
01332 else if (this->search_structure_[i].is_free_ && first_free == -1)
01333 first_free = static_cast<int> (i);
01334
01335 if (first_free > -1)
01336 {
01337 this->search_structure_[first_free].item_ = item;
01338 this->search_structure_[first_free].is_free_ = 0;
01339 return 0;
01340 }
01341 else if (i < this->max_size_)
01342 {
01343 this->search_structure_[i].item_ = item;
01344 this->search_structure_[i].is_free_ = 0;
01345 this->cur_size_++;
01346 return 0;
01347 }
01348 else
01349 {
01350 errno = ENOMEM;
01351 return -1;
01352 }
01353 }
01354
01355 template <class T> int
01356 ACE_Bounded_Set<T>::remove (const T &item)
01357 {
01358 ACE_TRACE ("ACE_Bounded_Set<T>::remove");
01359 for (size_t i = 0; i < this->cur_size_; i++)
01360 if (this->search_structure_[i].item_ == item)
01361 {
01362
01363 this->search_structure_[i].is_free_ = 1;
01364
01365
01366
01367 if (i + 1 == this->cur_size_)
01368 {
01369 while (i > 0 && this->search_structure_[--i].is_free_)
01370 continue;
01371
01372 if (i == 0 && this->search_structure_[i].is_free_)
01373 this->cur_size_ = 0;
01374 else
01375 this->cur_size_ = i + 1;
01376 }
01377 return 0;
01378 }
01379
01380 return -1;
01381 }
01382
01383 ACE_ALLOC_HOOK_DEFINE(ACE_Bounded_Set_Iterator)
01384
01385 template <class T> void
01386 ACE_Bounded_Set_Iterator<T>::dump (void) const
01387 {
01388 #if defined (ACE_HAS_DUMP)
01389 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::dump");
01390 #endif
01391 }
01392
01393 template <class T>
01394 ACE_Bounded_Set_Iterator<T>::ACE_Bounded_Set_Iterator (ACE_Bounded_Set<T> &s)
01395 : s_ (s),
01396 next_ (-1)
01397 {
01398 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::ACE_Bounded_Set_Iterator");
01399 this->advance ();
01400 }
01401
01402 template <class T> int
01403 ACE_Bounded_Set_Iterator<T>::advance (void)
01404 {
01405 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::advance");
01406
01407 for (++this->next_;
01408 static_cast<size_t> (this->next_) < this->s_.cur_size_
01409 && this->s_.search_structure_[this->next_].is_free_;
01410 ++this->next_)
01411 continue;
01412
01413 return static_cast<size_t> (this->next_) < this->s_.cur_size_;
01414 }
01415
01416 template <class T> int
01417 ACE_Bounded_Set_Iterator<T>::first (void)
01418 {
01419 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::first");
01420
01421 next_ = -1;
01422 return this->advance ();
01423 }
01424
01425 template <class T> int
01426 ACE_Bounded_Set_Iterator<T>::done (void) const
01427 {
01428 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::done");
01429
01430 return static_cast<ACE_CAST_CONST size_t> (this->next_) >=
01431 this->s_.cur_size_;
01432 }
01433
01434 template <class T> int
01435 ACE_Bounded_Set_Iterator<T>::next (T *&item)
01436 {
01437 ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::next");
01438 if (static_cast<size_t> (this->next_) < this->s_.cur_size_)
01439 {
01440 item = &this->s_.search_structure_[this->next_].item_;
01441 return 1;
01442 }
01443 else
01444 return 0;
01445 }
01446
01447 ACE_ALLOC_HOOK_DEFINE(ACE_DNode)
01448
01449 template <class T>
01450 ACE_DNode<T>::ACE_DNode (const T &i, ACE_DNode<T> *n, ACE_DNode<T> *p)
01451 : next_ (n), prev_ (p), item_ (i)
01452 {
01453 }
01454
01455 template <class T>
01456 ACE_DNode<T>::~ACE_DNode (void)
01457 {
01458 }
01459
01460
01461
01462 template <class T> void
01463 ACE_Unbounded_Stack_Iterator<T>::dump (void) const
01464 {
01465 #if defined (ACE_HAS_DUMP)
01466
01467 #endif
01468 }
01469
01470 template <class T>
01471 ACE_Unbounded_Stack_Iterator<T>::ACE_Unbounded_Stack_Iterator (ACE_Unbounded_Stack<T> &q)
01472 : current_ (q.head_->next_),
01473 stack_ (q)
01474 {
01475
01476 }
01477
01478 template <class T> int
01479 ACE_Unbounded_Stack_Iterator<T>::advance (void)
01480 {
01481
01482 this->current_ = this->current_->next_;
01483 return this->current_ != this->stack_.head_;
01484 }
01485
01486 template <class T> int
01487 ACE_Unbounded_Stack_Iterator<T>::first (void)
01488 {
01489
01490 this->current_ = this->stack_.head_->next_;
01491 return this->current_ != this->stack_.head_;
01492 }
01493
01494 template <class T> int
01495 ACE_Unbounded_Stack_Iterator<T>::done (void) const
01496 {
01497 ACE_TRACE ("ACE_Unbounded_Stack_Iterator<T>::done");
01498
01499 return this->current_ == this->stack_.head_;
01500 }
01501
01502 template <class T> int
01503 ACE_Unbounded_Stack_Iterator<T>::next (T *&item)
01504 {
01505
01506 if (this->current_ == this->stack_.head_)
01507 return 0;
01508 else
01509 {
01510 item = &this->current_->item_;
01511 return 1;
01512 }
01513 }
01514
01515
01516 ACE_ALLOC_HOOK_DEFINE(ACE_Ordered_MultiSet)
01517
01518
01519 template <class T>
01520 ACE_Ordered_MultiSet<T>::ACE_Ordered_MultiSet (ACE_Allocator *alloc)
01521 : head_ (0)
01522 , tail_ (0)
01523 , cur_size_ (0)
01524 , allocator_ (alloc)
01525 {
01526
01527
01528 if (this->allocator_ == 0)
01529 this->allocator_ = ACE_Allocator::instance ();
01530 }
01531
01532 template <class T>
01533 ACE_Ordered_MultiSet<T>::ACE_Ordered_MultiSet (const ACE_Ordered_MultiSet<T> &us)
01534 : head_ (0)
01535 , tail_ (0)
01536 , cur_size_ (0)
01537 , allocator_ (us.allocator_)
01538 {
01539 ACE_TRACE ("ACE_Ordered_MultiSet<T>::ACE_Ordered_MultiSet");
01540
01541 if (this->allocator_ == 0)
01542 this->allocator_ = ACE_Allocator::instance ();
01543
01544 this->copy_nodes (us);
01545 }
01546
01547 template <class T>
01548 ACE_Ordered_MultiSet<T>::~ACE_Ordered_MultiSet (void)
01549 {
01550
01551
01552 this->delete_nodes ();
01553 }
01554
01555
01556 template <class T> void
01557 ACE_Ordered_MultiSet<T>::operator= (const ACE_Ordered_MultiSet<T> &us)
01558 {
01559 ACE_TRACE ("ACE_Ordered_MultiSet<T>::operator=");
01560
01561 if (this != &us)
01562 {
01563 this->delete_nodes ();
01564 this->copy_nodes (us);
01565 }
01566 }
01567
01568
01569 template <class T> int
01570 ACE_Ordered_MultiSet<T>::insert (const T &item)
01571 {
01572
01573
01574 return this->insert_from (item, this->head_, 0);
01575 }
01576
01577 template <class T> int
01578 ACE_Ordered_MultiSet<T>::insert (const T &new_item,
01579 ITERATOR &iter)
01580 {
01581
01582
01583 return this->insert_from (new_item, iter.current_, &iter.current_);
01584 }
01585
01586 template <class T> int
01587 ACE_Ordered_MultiSet<T>::remove (const T &item)
01588 {
01589
01590
01591 ACE_DNode<T> *node = 0;
01592
01593 int result = locate (item, 0, node);
01594
01595
01596 if (node && (result == 0))
01597 {
01598 if (node->prev_)
01599 node->prev_->next_ = node->next_;
01600 else
01601 head_ = node->next_;
01602
01603 if (node->next_)
01604 node->next_->prev_ = node->prev_;
01605 else
01606 tail_ = node->prev_;
01607
01608 --this->cur_size_;
01609
01610 ACE_DES_FREE_TEMPLATE (node,
01611 this->allocator_->free,
01612 ACE_DNode,
01613 <T>);
01614 return 0;
01615 }
01616
01617 return -1;
01618 }
01619
01620 template <class T> int
01621 ACE_Ordered_MultiSet<T>::find (const T &item,
01622 ITERATOR &iter) const
01623 {
01624
01625 ACE_DNode<T> *node = iter.current_;
01626 int const result = locate (item, node, node);
01627
01628
01629 if (node && (result == 0))
01630 {
01631 iter.current_ = node;
01632 return 0;
01633 }
01634
01635 return -1;
01636 }
01637
01638
01639
01640 template <class T> void
01641 ACE_Ordered_MultiSet<T>::reset (void)
01642 {
01643 ACE_TRACE ("reset");
01644
01645 this->delete_nodes ();
01646 }
01647
01648 template <class T> void
01649 ACE_Ordered_MultiSet<T>::dump (void) const
01650 {
01651 #if defined (ACE_HAS_DUMP)
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668 #endif
01669 }
01670
01671 template <class T> int
01672 ACE_Ordered_MultiSet<T>::insert_from (const T &item, ACE_DNode<T> *position,
01673 ACE_DNode<T> **new_position)
01674 {
01675
01676
01677
01678 ACE_DNode<T> *temp = 0;
01679 ACE_NEW_MALLOC_RETURN (temp,
01680 static_cast<ACE_DNode<T>*> (this->allocator_->malloc (sizeof (ACE_DNode<T>))),
01681 ACE_DNode<T> (item),
01682 -1);
01683
01684 int result = locate (item, position, position);
01685
01686
01687 if (position)
01688 {
01689 switch (result)
01690 {
01691
01692 case -1:
01693
01694
01695 if (position->next_)
01696 {
01697
01698 position->next_->prev_ = temp;
01699 temp->next_ = position->next_;
01700 }
01701 else
01702
01703 tail_ = temp;
01704
01705
01706 temp->prev_ = position;
01707 position->next_ = temp;
01708
01709 break;
01710
01711
01712 case 0:
01713 case 1:
01714
01715
01716 if (position->prev_)
01717 {
01718
01719 position->prev_->next_ = temp;
01720 temp->prev_ = position->prev_;
01721 }
01722 else
01723
01724 head_ = temp;
01725
01726
01727 temp->next_ = position;
01728 position->prev_ = temp;
01729
01730 break;
01731
01732 default:
01733 return -1;
01734 }
01735 }
01736 else
01737 {
01738
01739 this->head_ = temp;
01740 this->tail_ = temp;
01741 }
01742
01743 ++this->cur_size_;
01744 if (new_position)
01745 *new_position = temp;
01746
01747 return 0;
01748 }
01749
01750 template <class T> int
01751 ACE_Ordered_MultiSet<T>::locate (const T &item, ACE_DNode<T> *start_position,
01752 ACE_DNode<T> *&new_position) const
01753 {
01754 if (! start_position)
01755 start_position = this->head_;
01756
01757
01758
01759 while (start_position && start_position->item_ < item &&
01760 start_position->next_)
01761 start_position = start_position->next_;
01762
01763
01764 while (start_position && item < start_position->item_ &&
01765 start_position->prev_)
01766 start_position = start_position->prev_;
01767
01768
01769 new_position = start_position;
01770
01771
01772 if (!new_position)
01773 return 1;
01774 else if (item < new_position->item_)
01775 return 1;
01776 else if (new_position->item_ < item)
01777 return -1;
01778 else
01779 return 0;
01780 }
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792 template <class T> void
01793 ACE_Ordered_MultiSet<T>::copy_nodes (const ACE_Ordered_MultiSet<T> &us)
01794 {
01795 ACE_DNode<T> *insertion_point = this->head_;
01796
01797 for (ACE_DNode<T> *curr = us.head_;
01798 curr != 0;
01799 curr = curr->next_)
01800 this->insert_from (curr->item_, insertion_point, &insertion_point);
01801 }
01802
01803 template <class T> void
01804 ACE_Ordered_MultiSet<T>::delete_nodes (void)
01805 {
01806
01807 for (ACE_DNode<T> *curr = this->head_;
01808 curr != 0;
01809 )
01810 {
01811 ACE_DNode<T> *temp = curr;
01812 curr = curr->next_;
01813 ACE_DES_FREE_TEMPLATE (temp,
01814 this->allocator_->free,
01815 ACE_DNode,
01816 <T>);
01817 }
01818
01819 this->head_ = 0;
01820 this->tail_ = 0;
01821 this->cur_size_ = 0;
01822 }
01823
01824 ACE_ALLOC_HOOK_DEFINE(ACE_Ordered_MultiSet_Iterator)
01825
01826 template <class T>
01827 ACE_Ordered_MultiSet_Iterator<T>::ACE_Ordered_MultiSet_Iterator (ACE_Ordered_MultiSet<T> &s)
01828 : current_ (s.head_),
01829 set_ (s)
01830 {
01831
01832 }
01833
01834 template <class T> int
01835 ACE_Ordered_MultiSet_Iterator<T>::next (T *&item) const
01836 {
01837
01838 if (this->current_)
01839 {
01840 item = &this->current_->item_;
01841 return 1;
01842 }
01843
01844 return 0;
01845 }
01846
01847 template <class T> T&
01848 ACE_Ordered_MultiSet_Iterator<T>::operator* (void)
01849 {
01850
01851 T *retv = 0;
01852
01853 int const result = this->next (retv);
01854 ACE_ASSERT (result != 0);
01855 ACE_UNUSED_ARG (result);
01856
01857 return *retv;
01858 }
01859
01860 ACE_ALLOC_HOOK_DEFINE (ACE_DLList_Node)
01861
01862 template <class T> T *
01863 ACE_DLList<T>::insert_tail (T *new_item)
01864 {
01865 ACE_DLList_Node *temp1 = 0;
01866 ACE_NEW_MALLOC_RETURN (temp1,
01867 static_cast<ACE_DLList_Node *> (this->allocator_->malloc (sizeof (ACE_DLList_Node))),
01868 ACE_DLList_Node (new_item),
01869 0);
01870 ACE_DLList_Node *temp2 = ACE_DLList_Base::insert_tail (temp1);
01871 return (T *) (temp2 ? temp2->item_ : 0);
01872 }
01873
01874 template <class T> T *
01875 ACE_DLList<T>::insert_head (T *new_item)
01876 {
01877 ACE_DLList_Node *temp1 = 0;
01878 ACE_NEW_MALLOC_RETURN (temp1,
01879 (ACE_DLList_Node *) this->allocator_->malloc (sizeof (ACE_DLList_Node)),
01880 ACE_DLList_Node (new_item), 0);
01881 ACE_DLList_Node *temp2 = ACE_DLList_Base::insert_head (temp1);
01882 return (T *) (temp2 ? temp2->item_ : 0);
01883 }
01884
01885 template <class T> T *
01886 ACE_DLList<T>::delete_head (void)
01887 {
01888 ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_head ();
01889 T *temp2 = (T *) (temp1 ? temp1->item_ : 0);
01890 ACE_DES_FREE (temp1,
01891 this->allocator_->free,
01892 ACE_DLList_Node);
01893
01894 return temp2;
01895 }
01896
01897 template <class T> T *
01898 ACE_DLList<T>::delete_tail (void)
01899 {
01900 ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_tail ();
01901 T *temp2 = (T *) (temp1 ? temp1->item_ : 0);
01902 ACE_DES_FREE (temp1,
01903 this->allocator_->free,
01904 ACE_DLList_Node);
01905 return temp2;
01906 }
01907
01908
01909
01910
01911
01912 template <class T> bool
01913 ACE_Array<T>::operator== (const ACE_Array<T> &s) const
01914 {
01915 if (this == &s)
01916 return true;
01917 else if (this->size () != s.size ())
01918 return false;
01919
01920 const size_t len = s.size ();
01921 for (size_t slot = 0; slot < len; ++slot)
01922 if ((*this)[slot] != s[slot])
01923 return false;
01924
01925 return true;
01926 }
01927
01928
01929
01930 ACE_END_VERSIONED_NAMESPACE_DECL
01931
01932 #endif