ACE/ace/Containers_T.inl

   1 // -*- C++ -*-
   2 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 template <class T> ACE_INLINE int
   5 ACE_Bounded_Stack<T>::is_empty (void) const
   6 {
   7   ACE_TRACE ("ACE_Bounded_Stack<T>::is_empty");
   8   return this->top_ == 0;
   9 }
  10
  11 template <class T> ACE_INLINE int
  12 ACE_Bounded_Stack<T>::is_full (void) const
  13 {
  14   ACE_TRACE ("ACE_Bounded_Stack<T>::is_full");
  15   return this->top_ >= this->size_;
  16 }
  17
  18 template <class T> ACE_INLINE int
  19 ACE_Bounded_Stack<T>::push (const T &new_item)
  20 {
  21   ACE_TRACE ("ACE_Bounded_Stack<T>::push");
  22   if (this->is_full () == 0)
  23     {
  24       this->stack_[this->top_++] = new_item;
  25       return 0;
  26     }
  27   else
  28     return -1;
  29 }
  30
  31 template <class T> ACE_INLINE int
  32 ACE_Bounded_Stack<T>::pop (T &item)
  33 {
  34   ACE_TRACE ("ACE_Bounded_Stack<T>::pop");
  35   if (this->is_empty () == 0)
  36     {
  37       item = this->stack_[--this->top_];
  38       return 0;
  39     }
  40   else
  41     return -1;
  42 }
  43
  44 template <class T> ACE_INLINE int
  45 ACE_Bounded_Stack<T>::top (T &item) const
  46 {
  47   ACE_TRACE ("ACE_Bounded_Stack<T>::top");
  48   if (this->is_empty () == 0)
  49     {
  50       item = this->stack_[this->top_ - 1];
  51       return 0;
  52     }
  53   else
  54     return -1;
  55 }
  56
  57 template <class T> ACE_INLINE size_t
  58 ACE_Bounded_Stack<T>::size (void) const
  59 {
  60   return this->size_;
  61 }
  62
  63 //----------------------------------------
  64
  65 template <class T, size_t ACE_SIZE> ACE_INLINE int
  66 ACE_Fixed_Stack<T, ACE_SIZE>::is_empty (void) const
  67 {
  68   ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::is_empty");
  69   return this->top_ == 0;
  70 }
  71
  72 template <class T, size_t ACE_SIZE> ACE_INLINE int
  73 ACE_Fixed_Stack<T, ACE_SIZE>::is_full (void) const
  74 {
  75   ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::is_full");
  76   return this->top_ >= this->size_;
  77 }
  78
  79 template <class T, size_t ACE_SIZE> ACE_INLINE int
  80 ACE_Fixed_Stack<T, ACE_SIZE>::push (const T &new_item)
  81 {
  82   ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::push");
  83   if (this->is_full () == 0)
  84     {
  85       this->stack_[this->top_++] = new_item;
  86       return 0;
  87     }
  88   else
  89     return -1;
  90 }
  91
  92 template <class T, size_t ACE_SIZE> ACE_INLINE int
  93 ACE_Fixed_Stack<T, ACE_SIZE>::pop (T &item)
  94 {
  95   ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::pop");
  96   if (this->is_empty () == 0)
  97     {
  98       item = this->stack_[--this->top_];
  99       return 0;
 100     }
 101   else
 102     return -1;
 103 }
 104
 105 template <class T, size_t ACE_SIZE> ACE_INLINE int
 106 ACE_Fixed_Stack<T, ACE_SIZE>::top (T &item) const
 107 {
 108   ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::top");
 109   if (this->is_empty () == 0)
 110     {
 111       item = this->stack_[this->top_ - 1];
 112       return 0;
 113     }
 114   else
 115     return -1;
 116 }
 117
 118 template <class T, size_t ACE_SIZE> ACE_INLINE size_t
 119 ACE_Fixed_Stack<T, ACE_SIZE>::size (void) const
 120 {
 121   return this->size_;
 122 }
 123
 124 template <class T> ACE_INLINE int
 125 ACE_Unbounded_Stack<T>::is_empty (void) const
 126 {
 127   //  ACE_TRACE ("ACE_Unbounded_Stack<T>::is_empty");
 128   return this->head_ == this->head_->next_;
 129 }
 130
 131 template <class T> ACE_INLINE int
 132 ACE_Unbounded_Stack<T>::top (T &item) const
 133 {
 134   ACE_TRACE ("ACE_Unbounded_Stack<T>::top");
 135   if (this->is_empty () == 0)
 136     {
 137       item = this->head_->next_->item_;
 138       return 0;
 139     }
 140   else
 141     return -1;
 142 }
 143
 144 template <class T> ACE_INLINE int
 145 ACE_Unbounded_Stack<T>::is_full (void) const
 146 {
 147   ACE_TRACE ("ACE_Unbounded_Stack<T>::is_full");
 148   return 0; // ???
 149 }
 150
 151 template <class T> ACE_INLINE size_t
 152 ACE_Unbounded_Stack<T>::size (void) const
 153 {
 154   return this->cur_size_;
 155 }
 156
 157 // ---
 158
 159
 160 // ---
 161
 162 template <class T, size_t ACE_SIZE> ACE_INLINE int
 163 ACE_Fixed_Set<T, ACE_SIZE>::is_empty (void) const
 164 {
 165   ACE_TRACE ("ACE_Fixed_Set<T>::is_empty");
 166   return this->cur_size_ == 0;
 167 }
 168
 169 template <class T, size_t ACE_SIZE> ACE_INLINE int
 170 ACE_Fixed_Set<T, ACE_SIZE>::is_full (void) const
 171 {
 172   ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::is_full");
 173   return this->cur_size_ == this->max_size_;
 174 }
 175
 176 // ---
 177
 178 template <class T> ACE_INLINE int
 179 ACE_Bounded_Set<T>::is_empty (void) const
 180 {
 181   ACE_TRACE ("ACE_Bounded_Set<T>::is_empty");
 182   return this->cur_size_ == 0;
 183 }
 184
 185 template <class T> ACE_INLINE int
 186 ACE_Bounded_Set<T>::is_full (void) const
 187 {
 188   ACE_TRACE ("ACE_Bounded_Set<T>::is_full");
 189   return this->cur_size_ == this->max_size_;
 190 }
 191
 192 // --
 193
 194 template <class T> ACE_INLINE int
 195 ACE_Ordered_MultiSet_Iterator<T>::first (void)
 196 {
 197   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::first");
 198   current_ = set_.head_;
 199
 200   return (current_ ? 1 : 0);
 201 }
 202
 203 template <class T> ACE_INLINE int
 204 ACE_Ordered_MultiSet_Iterator<T>::last (void)
 205 {
 206   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::last");
 207   current_ = set_.tail_;
 208
 209   return (current_ ? 1 : 0);
 210 }
 211
 212 template <class T> ACE_INLINE int
 213 ACE_Ordered_MultiSet_Iterator<T>::advance (void)
 214 {
 215   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::advance");
 216
 217   current_ = current_ ? current_->next_ : 0;
 218
 219   return (current_ ? 1 : 0);
 220 }
 221
 222 template <class T> ACE_INLINE int
 223 ACE_Ordered_MultiSet_Iterator<T>::retreat (void)
 224 {
 225   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::retreat");
 226
 227   current_ = current_ ? current_->prev_ : 0;
 228
 229   return (current_ ? 1 : 0);
 230 }
 231
 232 template <class T> ACE_INLINE int
 233 ACE_Ordered_MultiSet_Iterator<T>::done (void) const
 234 {
 235   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::done");
 236
 237   return (current_ ? 0 : 1);
 238 }
 239
 240 template <class T> ACE_INLINE void
 241 ACE_Ordered_MultiSet_Iterator<T>::dump (void) const
 242 {
 243 #if defined (ACE_HAS_DUMP)
 244 // ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::dump");
 245 #endif /* ACE_HAS_DUMP */
 246 }
 247
 248
 249
 250 // --
 251
 252 template <class T> ACE_INLINE int
 253 ACE_Ordered_MultiSet<T>::is_empty (void) const
 254 {
 255   ACE_TRACE ("ACE_Ordered_MultiSet<T>::is_empty");
 256   return this->cur_size_ > 0 ? 0 : 1;
 257 }
 258
 259 template <class T> ACE_INLINE size_t
 260 ACE_Ordered_MultiSet<T>::size (void) const
 261 {
 262 // ACE_TRACE ("ACE_Ordered_MultiSet<T>::size");
 263   return this->cur_size_;
 264 }
 265
 266 // ****************************************************************
 267
 268 template <class T> ACE_INLINE
 269 ACE_Array<T>::ACE_Array (size_t size,
 270                          ACE_Allocator *alloc)
 271   : ACE_Array_Base<T> (size, alloc)
 272 {
 273 }
 274
 275 template <class T> ACE_INLINE
 276 ACE_Array<T>::ACE_Array (size_t size,
 277                          const T &default_value,
 278                          ACE_Allocator *alloc)
 279   : ACE_Array_Base<T> (size, default_value, alloc)
 280 {
 281 }
 282
 283 // The copy constructor (performs initialization).
 284
 285 template <class T> ACE_INLINE
 286 ACE_Array<T>::ACE_Array (const ACE_Array<T> &s)
 287    : ACE_Array_Base<T> (s)
 288 {
 289 }
 290
 291 // Assignment operator (performs assignment).
 292
 293 template <class T> ACE_INLINE void
 294 ACE_Array<T>::operator= (const ACE_Array<T> &s)
 295 {
 296   // Check for "self-assignment".
 297
 298   if (this != &s)
 299     this->ACE_Array_Base<T>::operator= (s);
 300 }
 301
 302 // Compare this array with <s> for inequality.
 303
 304 template <class T> ACE_INLINE bool
 305 ACE_Array<T>::operator!= (const ACE_Array<T> &s) const
 306 {
 307   return !(*this == s);
 308 }
 309
 310 // ****************************************************************
 311
 312
 313 // ****************************************************************
 314
 315 template <class T> ACE_INLINE void
 316 ACE_DLList<T>::operator= (const ACE_DLList<T> &l)
 317 {
 318   *(ACE_DLList_Base *) this = l;
 319 }
 320
 321 template <class T> ACE_INLINE int
 322 ACE_DLList<T>::get (T *&item, size_t index)
 323 {
 324   ACE_DLList_Node *node;
 325   int result = ACE_DLList_Base::get (node, index);
 326   if (result != -1)
 327     item = (T *) node->item_;
 328   return result;
 329 }
 330
 331 template <class T> ACE_INLINE void
 332 ACE_DLList<T>::dump (void) const
 333 {
 334 #if defined (ACE_HAS_DUMP)
 335   ACE_DLList_Base::dump ();
 336 #endif /* ACE_HAS_DUMP */
 337 }
 338
 339 template <class T> ACE_INLINE int
 340 ACE_DLList<T>::remove (ACE_DLList_Node *n)
 341 {
 342   int result = ACE_DLList_Base::remove (n);
 343   ACE_DES_FREE (n,
 344                 this->allocator_->free,
 345                 ACE_DLList_Node);
 346   return result;
 347 }
 348
 349 template <class T> ACE_INLINE
 350 ACE_DLList<T>::ACE_DLList (ACE_Allocator *alloc)
 351   : ACE_DLList_Base (alloc)
 352 {
 353 }
 354
 355 template <class T> ACE_INLINE
 356 ACE_DLList<T>::ACE_DLList (const ACE_DLList<T> &l)
 357   : ACE_DLList_Base ((ACE_DLList<T> &) l)
 358 {
 359 }
 360
 361 template <class T> ACE_INLINE
 362 ACE_DLList<T>::~ACE_DLList (void)
 363 {
 364   while (this->delete_head ()) ;
 365 }
 366
 367 template <class T> ACE_INLINE int
 368 ACE_DLList_Iterator<T>::remove (void)
 369 {
 370   ACE_DLList_Node *temp = this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 371   this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance ();
 372   return list_->remove (temp);
 373 }
 374
 375 template <class T> ACE_INLINE
 376 ACE_DLList_Iterator<T>::ACE_DLList_Iterator (ACE_DLList<T> &l)
 377   : ACE_Double_Linked_List_Iterator <ACE_DLList_Node> ((ACE_DLList_Base &)l),
 378     list_ (&l)
 379 {
 380 }
 381
 382 template <class T> ACE_INLINE void
 383 ACE_DLList_Iterator<T>::reset (ACE_DLList<T> &l)
 384 {
 385   list_ = &l;
 386   this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::reset ((ACE_DLList_Base &)l);
 387 }
 388
 389 template <class T> ACE_INLINE int
 390 ACE_DLList_Iterator<T>::next (T *&ptr)
 391 {
 392   ACE_DLList_Node *temp =
 393     ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 394   if (temp)
 395     ptr = (T *) temp->item_;
 396   return temp ? 1 : 0;
 397 }
 398
 399 template <class T> ACE_INLINE T *
 400 ACE_DLList_Iterator<T>::next (void) const
 401 {
 402   ACE_DLList_Node *temp = ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 403   return (T *) (temp ? temp->item_ : 0);
 404 }
 405
 406 template <class T> ACE_INLINE int
 407 ACE_DLList_Iterator<T>::advance (void)
 408 {
 409   return this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance ();
 410 }
 411
 412 template <class T> ACE_INLINE void
 413 ACE_DLList_Iterator<T>::dump (void) const
 414 {
 415 #if defined (ACE_HAS_DUMP)
 416   ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::dump ();
 417 #endif /* ACE_HAS_DUMP */
 418 }
 419
 420
 421 template <class T> ACE_INLINE int
 422 ACE_DLList_Reverse_Iterator<T>::remove (void)
 423 {
 424   ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 425   this->ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance ();
 426   return list_->remove (temp);
 427 }
 428
 429 template <class T> ACE_INLINE
 430 ACE_DLList_Reverse_Iterator<T>::ACE_DLList_Reverse_Iterator (ACE_DLList<T> &l)
 431   : ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node> ((ACE_DLList_Base &)l),
 432     list_ (&l)
 433 {
 434 }
 435
 436 template <class T> ACE_INLINE void
 437 ACE_DLList_Reverse_Iterator<T>::reset (ACE_DLList<T> &l)
 438 {
 439   list_ = &l;
 440   this->ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::reset ((ACE_DLList_Base &)l);
 441 }
 442
 443 template <class T> ACE_INLINE int
 444 ACE_DLList_Reverse_Iterator<T>::advance (void)
 445 {
 446   return ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance ();
 447 }
 448
 449 template <class T> ACE_INLINE int
 450 ACE_DLList_Reverse_Iterator<T>::next (T *&ptr)
 451 {
 452   ACE_DLList_Node *temp =
 453     ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 454   if (temp == 0)
 455     return 0;
 456   ptr = (T *) temp->item_;
 457   return 1;
 458 }
 459
 460 template <class T> ACE_INLINE T *
 461 ACE_DLList_Reverse_Iterator<T>::next (void) const
 462 {
 463   ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 464   return (T *) (temp ? temp->item_ : 0);
 465 }
 466
 467
 468 template <class T> ACE_INLINE void
 469 ACE_DLList_Reverse_Iterator<T>::dump (void) const
 470 {
 471 #if defined (ACE_HAS_DUMP)
 472   ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::dump ();
 473 #endif /* ACE_HAS_DUMP */
 474 }
 475
 476 ACE_END_VERSIONED_NAMESPACE_DECL