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 () 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 () 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 () 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 () 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 () 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 () const
 120 {
 121   return this->size_;
 122 }
 123
 124 template <class T> ACE_INLINE int
 125 ACE_Unbounded_Stack<T>::is_empty () 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 () 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 () const
 153 {
 154   return this->cur_size_;
 155 }
 156
 157 // ---
 158
 159 template <class T, size_t ACE_SIZE> ACE_INLINE int
 160 ACE_Fixed_Set<T, ACE_SIZE>::is_empty () const
 161 {
 162   ACE_TRACE ("ACE_Fixed_Set<T>::is_empty");
 163   return this->cur_size_ == 0;
 164 }
 165
 166 template <class T, size_t ACE_SIZE> ACE_INLINE int
 167 ACE_Fixed_Set<T, ACE_SIZE>::is_full () const
 168 {
 169   ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::is_full");
 170   return this->cur_size_ == this->max_size_;
 171 }
 172
 173 // ---
 174
 175 template <class T> ACE_INLINE int
 176 ACE_Bounded_Set<T>::is_empty () const
 177 {
 178   ACE_TRACE ("ACE_Bounded_Set<T>::is_empty");
 179   return this->cur_size_ == 0;
 180 }
 181
 182 template <class T> ACE_INLINE int
 183 ACE_Bounded_Set<T>::is_full () const
 184 {
 185   ACE_TRACE ("ACE_Bounded_Set<T>::is_full");
 186   return this->cur_size_ == this->max_size_;
 187 }
 188
 189 // --
 190
 191 template <class T> ACE_INLINE int
 192 ACE_Ordered_MultiSet_Iterator<T>::first ()
 193 {
 194   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::first");
 195   current_ = set_.head_;
 196
 197   return (current_ ? 1 : 0);
 198 }
 199
 200 template <class T> ACE_INLINE int
 201 ACE_Ordered_MultiSet_Iterator<T>::last ()
 202 {
 203   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::last");
 204   current_ = set_.tail_;
 205
 206   return (current_ ? 1 : 0);
 207 }
 208
 209 template <class T> ACE_INLINE int
 210 ACE_Ordered_MultiSet_Iterator<T>::advance ()
 211 {
 212   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::advance");
 213
 214   current_ = current_ ? current_->next_ : 0;
 215
 216   return (current_ ? 1 : 0);
 217 }
 218
 219 template <class T> ACE_INLINE int
 220 ACE_Ordered_MultiSet_Iterator<T>::retreat ()
 221 {
 222   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::retreat");
 223
 224   current_ = current_ ? current_->prev_ : 0;
 225
 226   return (current_ ? 1 : 0);
 227 }
 228
 229 template <class T> ACE_INLINE int
 230 ACE_Ordered_MultiSet_Iterator<T>::done () const
 231 {
 232   ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::done");
 233
 234   return (current_ ? 0 : 1);
 235 }
 236
 237 template <class T> ACE_INLINE void
 238 ACE_Ordered_MultiSet_Iterator<T>::dump () const
 239 {
 240 #if defined (ACE_HAS_DUMP)
 241 // ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::dump");
 242 #endif /* ACE_HAS_DUMP */
 243 }
 244
 245 template <class T> ACE_INLINE int
 246 ACE_Ordered_MultiSet<T>::is_empty () const
 247 {
 248   ACE_TRACE ("ACE_Ordered_MultiSet<T>::is_empty");
 249   return this->cur_size_ > 0 ? 0 : 1;
 250 }
 251
 252 template <class T> ACE_INLINE size_t
 253 ACE_Ordered_MultiSet<T>::size () const
 254 {
 255 // ACE_TRACE ("ACE_Ordered_MultiSet<T>::size");
 256   return this->cur_size_;
 257 }
 258
 259 // ****************************************************************
 260
 261 template <class T> ACE_INLINE
 262 ACE_Array<T>::ACE_Array (size_t size,
 263                          ACE_Allocator *alloc)
 264   : ACE_Array_Base<T> (size, alloc)
 265 {
 266 }
 267
 268 template <class T> ACE_INLINE
 269 ACE_Array<T>::ACE_Array (size_t size,
 270                          const T &default_value,
 271                          ACE_Allocator *alloc)
 272   : ACE_Array_Base<T> (size, default_value, alloc)
 273 {
 274 }
 275
 276 // The copy constructor (performs initialization).
 277
 278 template <class T> ACE_INLINE
 279 ACE_Array<T>::ACE_Array (const ACE_Array<T> &s)
 280    : ACE_Array_Base<T> (s)
 281 {
 282 }
 283
 284 // Assignment operator (performs assignment).
 285
 286 template <class T> ACE_INLINE void
 287 ACE_Array<T>::operator= (const ACE_Array<T> &s)
 288 {
 289   // Check for "self-assignment".
 290
 291   if (this != &s)
 292     this->ACE_Array_Base<T>::operator= (s);
 293 }
 294
 295 // Compare this array with <s> for inequality.
 296
 297 template <class T> ACE_INLINE bool
 298 ACE_Array<T>::operator!= (const ACE_Array<T> &s) const
 299 {
 300   return !(*this == s);
 301 }
 302
 303 // ****************************************************************
 304
 305
 306 // ****************************************************************
 307
 308 template <class T> ACE_INLINE void
 309 ACE_DLList<T>::operator= (const ACE_DLList<T> &l)
 310 {
 311   *(ACE_DLList_Base *) this = l;
 312 }
 313
 314 template <class T> ACE_INLINE int
 315 ACE_DLList<T>::get (T *&item, size_t index)
 316 {
 317   ACE_DLList_Node *node;
 318   int result = ACE_DLList_Base::get (node, index);
 319   if (result != -1)
 320     item = (T *) node->item_;
 321   return result;
 322 }
 323
 324 template <class T> ACE_INLINE void
 325 ACE_DLList<T>::dump () const
 326 {
 327 #if defined (ACE_HAS_DUMP)
 328   ACE_DLList_Base::dump ();
 329 #endif /* ACE_HAS_DUMP */
 330 }
 331
 332 template <class T> ACE_INLINE int
 333 ACE_DLList<T>::remove (ACE_DLList_Node *n)
 334 {
 335   int result = ACE_DLList_Base::remove (n);
 336   ACE_DES_FREE (n,
 337                 this->allocator_->free,
 338                 ACE_DLList_Node);
 339   return result;
 340 }
 341
 342 template <class T> ACE_INLINE
 343 ACE_DLList<T>::ACE_DLList (ACE_Allocator *alloc)
 344   : ACE_DLList_Base (alloc)
 345 {
 346 }
 347
 348 template <class T> ACE_INLINE
 349 ACE_DLList<T>::ACE_DLList (const ACE_DLList<T> &l)
 350   : ACE_DLList_Base ((ACE_DLList<T> &) l)
 351 {
 352 }
 353
 354 template <class T> ACE_INLINE
 355 ACE_DLList<T>::~ACE_DLList ()
 356 {
 357   while (this->delete_head ()) ;
 358 }
 359
 360 template <class T> ACE_INLINE int
 361 ACE_DLList_Iterator<T>::remove ()
 362 {
 363   ACE_DLList_Node *temp = this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 364   this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance ();
 365   return list_->remove (temp);
 366 }
 367
 368 template <class T> ACE_INLINE
 369 ACE_DLList_Iterator<T>::ACE_DLList_Iterator (ACE_DLList<T> &l)
 370   : ACE_Double_Linked_List_Iterator <ACE_DLList_Node> ((ACE_DLList_Base &)l),
 371     list_ (&l)
 372 {
 373 }
 374
 375 template <class T> ACE_INLINE void
 376 ACE_DLList_Iterator<T>::reset (ACE_DLList<T> &l)
 377 {
 378   list_ = &l;
 379   this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::reset ((ACE_DLList_Base &)l);
 380 }
 381
 382 template <class T> ACE_INLINE int
 383 ACE_DLList_Iterator<T>::next (T *&ptr)
 384 {
 385   ACE_DLList_Node *temp =
 386     ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 387   if (temp)
 388     ptr = (T *) temp->item_;
 389   return temp ? 1 : 0;
 390 }
 391
 392 template <class T> ACE_INLINE T *
 393 ACE_DLList_Iterator<T>::next () const
 394 {
 395   ACE_DLList_Node *temp = ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next ();
 396   return (T *) (temp ? temp->item_ : 0);
 397 }
 398
 399 template <class T> ACE_INLINE int
 400 ACE_DLList_Iterator<T>::advance ()
 401 {
 402   return this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance ();
 403 }
 404
 405 template <class T> ACE_INLINE void
 406 ACE_DLList_Iterator<T>::dump () const
 407 {
 408 #if defined (ACE_HAS_DUMP)
 409   ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::dump ();
 410 #endif /* ACE_HAS_DUMP */
 411 }
 412
 413
 414 template <class T> ACE_INLINE int
 415 ACE_DLList_Reverse_Iterator<T>::remove ()
 416 {
 417   ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 418   this->ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance ();
 419   return list_->remove (temp);
 420 }
 421
 422 template <class T> ACE_INLINE
 423 ACE_DLList_Reverse_Iterator<T>::ACE_DLList_Reverse_Iterator (ACE_DLList<T> &l)
 424   : ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node> ((ACE_DLList_Base &)l),
 425     list_ (&l)
 426 {
 427 }
 428
 429 template <class T> ACE_INLINE void
 430 ACE_DLList_Reverse_Iterator<T>::reset (ACE_DLList<T> &l)
 431 {
 432   list_ = &l;
 433   this->ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::reset ((ACE_DLList_Base &)l);
 434 }
 435
 436 template <class T> ACE_INLINE int
 437 ACE_DLList_Reverse_Iterator<T>::advance ()
 438 {
 439   return ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance ();
 440 }
 441
 442 template <class T> ACE_INLINE int
 443 ACE_DLList_Reverse_Iterator<T>::next (T *&ptr)
 444 {
 445   ACE_DLList_Node *temp =
 446     ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 447   if (temp == 0)
 448     return 0;
 449   ptr = (T *) temp->item_;
 450   return 1;
 451 }
 452
 453 template <class T> ACE_INLINE T *
 454 ACE_DLList_Reverse_Iterator<T>::next () const
 455 {
 456   ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next ();
 457   return (T *) (temp ? temp->item_ : 0);
 458 }
 459
 460
 461 template <class T> ACE_INLINE void
 462 ACE_DLList_Reverse_Iterator<T>::dump () const
 463 {
 464 #if defined (ACE_HAS_DUMP)
 465   ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::dump ();
 466 #endif /* ACE_HAS_DUMP */
 467 }
 468
 469 ACE_END_VERSIONED_NAMESPACE_DECL