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