ACE/ace/Map_Manager.inl

   1 // -*- C++ -*-
   2 #include "ace/Guard_T.h"
   3 #include "ace/Log_Category.h"
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 template <class EXT_ID, class INT_ID> ACE_INLINE ACE_UINT32
   8 ACE_Map_Entry<EXT_ID, INT_ID>::next () const
   9 {
  10   return this->next_;
  11 }
  12
  13 template <class EXT_ID, class INT_ID> ACE_INLINE void
  14 ACE_Map_Entry<EXT_ID, INT_ID>::next (ACE_UINT32 n)
  15 {
  16   this->next_ = n;
  17 }
  18
  19 template <class EXT_ID, class INT_ID> ACE_INLINE ACE_UINT32
  20 ACE_Map_Entry<EXT_ID, INT_ID>::prev () const
  21 {
  22   return this->prev_;
  23 }
  24
  25 template <class EXT_ID, class INT_ID> ACE_INLINE void
  26 ACE_Map_Entry<EXT_ID, INT_ID>::prev (ACE_UINT32 p)
  27 {
  28   this->prev_ = p;
  29 }
  30
  31 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
  32 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Manager (size_t size,
  33                                                             ACE_Allocator *alloc)
  34   : allocator_ (0),
  35     search_structure_ (0),
  36     total_size_ (0),
  37     cur_size_ (0)
  38 {
  39   if (this->open (size, alloc) == -1)
  40     ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Map_Manager\n")));
  41 }
  42
  43 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
  44 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Manager (ACE_Allocator *alloc)
  45   : allocator_ (0),
  46     search_structure_ (0),
  47     total_size_ (0),
  48     cur_size_ (0)
  49 {
  50   if (this->open (ACE_DEFAULT_MAP_SIZE, alloc) == -1)
  51     ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Map_Manager\n")));
  52 }
  53
  54 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
  55 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close ()
  56 {
  57   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
  58
  59   return this->close_i ();
  60 }
  61
  62 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
  63 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::~ACE_Map_Manager ()
  64 {
  65   this->close ();
  66 }
  67
  68 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
  69 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::bind (const EXT_ID &ext_id,
  70                                                  const INT_ID &int_id)
  71 {
  72   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
  73
  74   return this->bind_i (ext_id,
  75                        int_id);
  76 }
  77
  78 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
  79 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rebind (const EXT_ID &ext_id,
  80                                                    const INT_ID &int_id,
  81                                                    EXT_ID &old_ext_id,
  82                                                    INT_ID &old_int_id)
  83 {
  84   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
  85
  86   return this->rebind_i (ext_id,
  87                          int_id,
  88                          old_ext_id,
  89                          old_int_id);
  90 }
  91
  92 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
  93 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rebind (const EXT_ID &ext_id,
  94                                                    const INT_ID &int_id,
  95                                                    INT_ID &old_int_id)
  96 {
  97   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
  98
  99   return this->rebind_i (ext_id,
 100                          int_id,
 101                          old_int_id);
 102 }
 103
 104 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 105 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rebind (const EXT_ID &ext_id,
 106                                                    const INT_ID &int_id)
 107 {
 108   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
 109
 110   return this->rebind_i (ext_id,
 111                          int_id);
 112 }
 113
 114 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 115 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::trybind (const EXT_ID &ext_id,
 116                                                     INT_ID &int_id)
 117 {
 118   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
 119
 120   return this->trybind_i (ext_id,
 121                           int_id);
 122 }
 123
 124 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 125 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::find (const EXT_ID &ext_id) const
 126 {
 127   ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> *nc_this =
 128     (ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> *) this;
 129   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, nc_this->lock_, -1);
 130
 131   ACE_UINT32 slot = 0;
 132   return nc_this->find_and_return_index (ext_id, slot);
 133 }
 134
 135 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 136 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::find (const EXT_ID &ext_id,
 137                                                  INT_ID &int_id) const
 138 {
 139   ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> *nc_this =
 140     (ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> *) this;
 141   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, nc_this->lock_, -1);
 142
 143   return nc_this->find_i (ext_id, int_id);
 144 }
 145
 146 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 147 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind_i (const EXT_ID &ext_id)
 148 {
 149   // Unbind the entry.
 150   ACE_UINT32 slot = 0;
 151   return this->unbind_and_return_index (ext_id,
 152                                         slot);
 153 }
 154
 155 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 156 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind (const EXT_ID &ext_id,
 157                                                    INT_ID &int_id)
 158 {
 159   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
 160
 161   return this->unbind_i (ext_id,
 162                          int_id);
 163 }
 164
 165 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 166 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind (const EXT_ID &ext_id)
 167 {
 168   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
 169   return this->unbind_i (ext_id);
 170 }
 171
 172 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE size_t
 173 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::current_size () const
 174 {
 175   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, static_cast<size_t> (-1));
 176   return this->cur_size_;
 177 }
 178
 179 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE size_t
 180 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::total_size () const
 181 {
 182   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, static_cast<size_t> (-1));
 183   return this->total_size_;
 184 }
 185
 186 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_LOCK &
 187 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::mutex ()
 188 {
 189   return this->lock_;
 190 }
 191
 192 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE void
 193 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::move_from_free_list_to_occupied_list (ACE_UINT32 slot)
 194 {
 195   this->shared_move (slot,
 196                      this->free_list_,
 197                      this->free_list_id (),
 198                      this->occupied_list_,
 199                      this->occupied_list_id ());
 200 }
 201
 202 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE void
 203 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::move_from_occupied_list_to_free_list (ACE_UINT32 slot)
 204 {
 205   this->shared_move (slot,
 206                      this->occupied_list_,
 207                      this->occupied_list_id (),
 208                      this->free_list_,
 209                      this->free_list_id ());
 210 }
 211
 212 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 213 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::equal (const EXT_ID &id1,
 214                                                   const EXT_ID &id2)
 215 {
 216   return id1 == id2;
 217 }
 218
 219 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_UINT32
 220 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_list_id () const
 221 {
 222   // If you change ~0, please change
 223   // ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key()
 224   // accordingly.
 225   return (ACE_UINT32) ~0;
 226 }
 227
 228 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_UINT32
 229 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::occupied_list_id () const
 230 {
 231   return (ACE_UINT32) ~1;
 232 }
 233
 234 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 235 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 236 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::begin ()
 237 {
 238   return ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this);
 239 }
 240
 241 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 242 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 243 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::end ()
 244 {
 245   return ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this, 1);
 246 }
 247
 248 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 249 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 250 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rbegin ()
 251 {
 252   return ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this);
 253 }
 254
 255 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 256 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 257 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rend ()
 258 {
 259   return ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this, 1);
 260 }
 261
 262 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 263 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Iterator_Base (ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm)
 264   : map_man_ (&mm),
 265     next_ (map_man_->occupied_list_id ())
 266 {
 267 }
 268
 269 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 270 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::next (ACE_Map_Entry<EXT_ID, INT_ID> *&mm) const
 271 {
 272   if (this->next_ != this->map_man_->occupied_list_id ())
 273     {
 274       mm = &this->map_man_->search_structure_[this->next_];
 275       return 1;
 276     }
 277   else
 278     return 0;
 279 }
 280
 281 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 282 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done () const
 283 {
 284   return this->next_ == this->map_man_->occupied_list_id ();
 285 }
 286
 287 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 288 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i ()
 289 {
 290
 291 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 292
 293   while (1)
 294     {
 295       // Go to the next item in the list.
 296       this->next_ = this->map_man_->search_structure_[this->next_].next ();
 297
 298       // Stop if we reach the end.
 299       if (this->done ())
 300         break;
 301
 302       // Break if we find a non-free slot.
 303       if (!this->map_man_->search_structure_[this->next_].free_)
 304         {
 305           break;
 306         }
 307     }
 308
 309 #else
 310
 311   this->next_ = this->map_man_->search_structure_[this->next_].next ();
 312
 313 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 314
 315   return this->next_ != this->map_man_->occupied_list_id ();
 316 }
 317
 318 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 319 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i ()
 320 {
 321
 322 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 323
 324   while (1)
 325     {
 326       // Go to the prev item in the list.
 327       this->next_ = this->map_man_->search_structure_[this->next_].prev ();
 328
 329       // Stop if we reach the end.
 330       if (this->done ())
 331         break;
 332
 333       // Break if we find a non-free slot.
 334       if (!this->map_man_->search_structure_[this->next_].free_)
 335         {
 336           break;
 337         }
 338     }
 339
 340 #else
 341
 342   this->next_ = this->map_man_->search_structure_[this->next_].prev ();
 343
 344 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 345
 346   return this->next_ != this->map_man_->occupied_list_id ();
 347 }
 348
 349 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 350 ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &
 351 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map ()
 352 {
 353   return *this->map_man_;
 354 }
 355
 356 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE bool
 357 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator== (const ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &rhs) const
 358 {
 359   return (this->map_man_ == rhs.map_man_ &&
 360           this->next_ == rhs.next_);
 361 }
 362
 363 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE bool
 364 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator!= (const ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &rhs) const
 365 {
 366   return !this->operator== (rhs);
 367 }
 368
 369 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 370 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Const_Iterator_Base (const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm)
 371   : map_man_ (&mm),
 372     next_ (this->map_man_->occupied_list_id ())
 373 {
 374 }
 375
 376 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 377 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::next (ACE_Map_Entry<EXT_ID, INT_ID> *&mm) const
 378 {
 379   if (this->next_ != this->map_man_->occupied_list_id ())
 380     {
 381       mm = &this->map_man_->search_structure_[this->next_];
 382       return 1;
 383     }
 384   else
 385     return 0;
 386 }
 387
 388 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 389 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done () const
 390 {
 391   return this->next_ == this->map_man_->occupied_list_id ();
 392 }
 393
 394 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 395 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i ()
 396 {
 397
 398 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 399
 400   while (1)
 401     {
 402       // Go to the next item in the list.
 403       this->next_ = this->map_man_->search_structure_[this->next_].next ();
 404
 405       // Stop if we reach the end.
 406       if (this->done ())
 407         break;
 408
 409       // Break if we find a non-free slot.
 410       if (!this->map_man_->search_structure_[this->next_].free_)
 411         {
 412           break;
 413         }
 414     }
 415
 416 #else
 417
 418   this->next_ = this->map_man_->search_structure_[this->next_].next ();
 419
 420 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 421
 422   return this->next_ != this->map_man_->occupied_list_id ();
 423 }
 424
 425 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 426 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i ()
 427 {
 428
 429 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 430
 431   while (1)
 432     {
 433       // Go to the prev item in the list.
 434       this->next_ = this->map_man_->search_structure_[this->next_].prev ();
 435
 436       // Stop if we reach the end.
 437       if (this->done ())
 438         break;
 439
 440       // Break if we find a non-free slot.
 441       if (!this->map_man_->search_structure_[this->next_].free_)
 442         {
 443           break;
 444         }
 445     }
 446
 447 #else
 448
 449   this->next_ = this->map_man_->search_structure_[this->next_].prev ();
 450
 451 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 452
 453   return this->next_ != this->map_man_->occupied_list_id ();
 454 }
 455
 456 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 457 const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &
 458 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map () const
 459 {
 460   return *this->map_man_;
 461 }
 462
 463 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE bool
 464 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator== (const ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &rhs) const
 465 {
 466   return (this->map_man_ == rhs.map_man_ &&
 467           this->next_ == rhs.next_);
 468 }
 469
 470 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE bool
 471 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator!= (const ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &rhs) const
 472 {
 473   return !this->operator== (rhs);
 474 }
 475
 476 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 477 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Iterator (ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm,
 478                                                               int pass_end)
 479   : ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> (mm)
 480 {
 481   if (!pass_end)
 482     {
 483
 484 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 485
 486       // Start here.
 487       this->next_ = this->map_man_->occupied_list_.next ();
 488
 489       while (1)
 490         {
 491           // Stop if we reach the end.
 492           if (this->done ())
 493             break;
 494
 495           // Break if we find a non-free slot.
 496           if (!this->map_man_->search_structure_[this->next_].free_)
 497             {
 498               break;
 499             }
 500
 501           // Go to the next item in the list.
 502           this->next_ = this->map_man_->search_structure_[this->next_].next ();
 503         }
 504
 505 #else
 506
 507       this->next_ = this->map_man_->occupied_list_.next ();
 508
 509 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 510
 511     }
 512 }
 513
 514 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 515 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance ()
 516 {
 517   return this->forward_i ();
 518 }
 519
 520 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 521 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 522 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ ()
 523 {
 524   this->forward_i ();
 525   return *this;
 526 }
 527
 528 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 529 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 530 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 531 {
 532   ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 533   ++*this;
 534   return retv;
 535 }
 536
 537 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 538 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 539 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- ()
 540 {
 541   this->reverse_i ();
 542   return *this;
 543 }
 544
 545 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 546 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 547 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 548 {
 549   ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 550   --*this;
 551   return retv;
 552 }
 553
 554 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 555 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Const_Iterator (const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm,
 556                                                                           int pass_end)
 557   : ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> (mm)
 558 {
 559   if (!pass_end)
 560     {
 561
 562 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 563
 564       // Start here.
 565       this->next_ = this->map_man_->occupied_list_.next ();
 566
 567       while (1)
 568         {
 569           // Stop if we reach the end.
 570           if (this->done ())
 571             break;
 572
 573           // Break if we find a non-free slot.
 574           if (!this->map_man_->search_structure_[this->next_].free_)
 575             {
 576               break;
 577             }
 578
 579           // Go to the next item in the list.
 580           this->next_ = this->map_man_->search_structure_[this->next_].next ();
 581         }
 582
 583 #else
 584
 585       this->next_ = this->map_man_->occupied_list_.next ();
 586
 587 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 588
 589     }
 590 }
 591
 592 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 593 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance ()
 594 {
 595   return this->forward_i ();
 596 }
 597
 598 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 599 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 600 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ ()
 601 {
 602   this->forward_i ();
 603   return *this;
 604 }
 605
 606 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 607 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 608 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 609 {
 610   ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 611   ++*this;
 612   return retv;
 613 }
 614
 615 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 616 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 617 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- ()
 618 {
 619   this->reverse_i ();
 620   return *this;
 621 }
 622
 623 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 624 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 625 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 626 {
 627   ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 628   --*this;
 629   return retv;
 630 }
 631
 632 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 633 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Reverse_Iterator (ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm,
 634                                                                               int pass_end)
 635   : ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> (mm)
 636 {
 637   if (!pass_end)
 638     {
 639
 640 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 641
 642       // Start here.
 643       this->next_ = this->map_man_->occupied_list_.prev ();
 644
 645       while (1)
 646         {
 647           // Stop if we reach the end.
 648           if (this->done ())
 649             break;
 650
 651           // Break if we find a non-free slot.
 652           if (!this->map_man_->search_structure_[this->next_].free_)
 653             {
 654               break;
 655             }
 656
 657           // Go to the prev item in the list.
 658           this->next_ = this->map_man_->search_structure_[this->next_].prev ();
 659         }
 660
 661 #else
 662
 663       this->next_ = this->map_man_->occupied_list_.prev ();
 664
 665 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 666
 667 }
 668 }
 669
 670 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int
 671 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance ()
 672 {
 673   return this->reverse_i ();
 674 }
 675
 676 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 677 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 678 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ ()
 679 {
 680   this->reverse_i ();
 681   return *this;
 682 }
 683
 684 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 685 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 686 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 687 {
 688   ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 689   ++*this;
 690   return retv;
 691 }
 692
 693 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 694 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &
 695 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- ()
 696 {
 697   this->forward_i ();
 698   return *this;
 699 }
 700
 701 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 702 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 703 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 704 {
 705   ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
 706   --*this;
 707   return retv;
 708 }
 709
 710 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 711 ACE_Map_Entry<EXT_ID, INT_ID>&
 712 ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* () const
 713 {
 714   ACE_Map_Entry<EXT_ID, INT_ID> *retv = 0;
 715
 716   int const result = this->next (retv);
 717   ACE_ASSERT (result != 0);
 718   ACE_UNUSED_ARG (result);
 719
 720   return *retv;
 721 }
 722
 723 template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE
 724 ACE_Map_Entry<EXT_ID, INT_ID>&
 725 ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* () const
 726 {
 727   ACE_Map_Entry<EXT_ID, INT_ID> *retv = 0;
 728
 729   int const result = this->next (retv);
 730   ACE_ASSERT (result != 0);
 731   ACE_UNUSED_ARG (result);
 732
 733   return *retv;
 734 }
 735
 736
 737 ACE_END_VERSIONED_NAMESPACE_DECL