ACE/ace/Map_T.cpp

   1 #ifndef ACE_MAP_T_CPP
   2 #define ACE_MAP_T_CPP
   3
   4 #include "ace/Map_T.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #if !defined (__ACE_INLINE__)
  11 #include "ace/Map_T.inl"
  12 #endif /* __ACE_INLINE__ */
  13
  14 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 template <class KEY, class VALUE>
  17 ACE_Map<KEY, VALUE>::~ACE_Map (void)
  18 {
  19 }
  20
  21 template <class T>
  22 ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void)
  23 {
  24 }
  25
  26 template <class T>
  27 ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void)
  28 {
  29 }
  30
  31 template <class T, class IMPLEMENTATION, class ENTRY>
  32 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void)
  33 {
  34 }
  35
  36
  37 template <class T, class IMPLEMENTATION, class ENTRY> ACE_Iterator_Impl<T> *
  38 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
  39 {
  40   ACE_Iterator_Impl<T> *temp = 0;
  41   ACE_NEW_RETURN (temp,
  42                   (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
  43                   0);
  44   return temp;
  45 }
  46
  47 template <class T, class IMPLEMENTATION, class ENTRY> int
  48 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const
  49 {
  50   const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
  51     = dynamic_cast<const ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);
  52
  53   return this->implementation_ == rhs_local.implementation_;
  54 }
  55
  56 template <class T, class IMPLEMENTATION, class ENTRY> T
  57 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
  58 {
  59   ENTRY &entry = *this->implementation_;
  60   return T (entry.ext_id_,
  61             entry.int_id_);
  62 }
  63
  64 template <class T, class IMPLEMENTATION, class ENTRY> void
  65 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
  66 {
  67   ++this->implementation_;
  68 }
  69
  70 template <class T, class IMPLEMENTATION, class ENTRY> void
  71 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
  72 {
  73   --this->implementation_;
  74 }
  75
  76 template <class T, class IMPLEMENTATION, class ENTRY>
  77 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void)
  78 {
  79 }
  80
  81 template <class T, class IMPLEMENTATION, class ENTRY> ACE_Reverse_Iterator_Impl<T> *
  82 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
  83 {
  84   ACE_Reverse_Iterator_Impl<T> *temp = 0;
  85   ACE_NEW_RETURN (temp,
  86                   (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
  87                   0);
  88   return temp;
  89 }
  90
  91
  92 template <class T, class IMPLEMENTATION, class ENTRY> int
  93 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
  94 {
  95   const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
  96     = dynamic_cast<const ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);
  97
  98   return this->implementation_ == rhs_local.implementation_;
  99 }
 100
 101 template <class T, class IMPLEMENTATION, class ENTRY> T
 102 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
 103 {
 104   ENTRY &entry = *this->implementation_;
 105   return T (entry.ext_id_,
 106             entry.int_id_);
 107 }
 108
 109 template <class T, class IMPLEMENTATION, class ENTRY> void
 110 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
 111 {
 112   ++this->implementation_;
 113 }
 114
 115 template <class T, class IMPLEMENTATION, class ENTRY> void
 116 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
 117 {
 118   --this->implementation_;
 119 }
 120
 121
 122 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY>
 123 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void)
 124 {
 125 }
 126
 127 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 128 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length,
 129                                                                                    ACE_Allocator *alloc)
 130 {
 131   return this->implementation_.open (length,
 132                                      alloc);
 133 }
 134
 135 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 136 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void)
 137 {
 138   return this->implementation_.close ();
 139 }
 140
 141 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 142 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key,
 143                                                                                    const VALUE &value)
 144 {
 145   return this->implementation_.bind (key,
 146                                      value);
 147 }
 148
 149 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 150 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value,
 151                                                                                               KEY &key)
 152 {
 153   return this->implementation_.bind_modify_key (value,
 154                                                 key);
 155 }
 156
 157 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 158 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key)
 159 {
 160   return this->implementation_.create_key (key);
 161 }
 162
 163 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 164 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value,
 165                                                                                               KEY &key)
 166 {
 167   return this->implementation_.bind_create_key (value,
 168                                                 key);
 169 }
 170
 171 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 172 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value)
 173 {
 174   return this->implementation_.bind_create_key (value);
 175 }
 176
 177 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 178 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key,
 179                                                                                           KEY &original_key)
 180 {
 181   return this->implementation_.recover_key (modified_key,
 182                                             original_key);
 183 }
 184
 185 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 186 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
 187                                                                                      const VALUE &value)
 188 {
 189   return this->implementation_.rebind (key,
 190                                        value);
 191 }
 192
 193 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 194 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
 195                                                                                      const VALUE &value,
 196                                                                                      VALUE &old_value)
 197 {
 198   return this->implementation_.rebind (key,
 199                                        value,
 200                                        old_value);
 201 }
 202
 203 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 204 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
 205                                                                                      const VALUE &value,
 206                                                                                      KEY &old_key,
 207                                                                                      VALUE &old_value)
 208 {
 209   return this->implementation_.rebind (key,
 210                                        value,
 211                                        old_key,
 212                                        old_value);
 213 }
 214
 215 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 216 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key,
 217                                                                                       VALUE &value)
 218 {
 219   return this->implementation_.trybind (key,
 220                                         value);
 221 }
 222
 223 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 224 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key,
 225                                                                                    VALUE &value)
 226 {
 227   return this->implementation_.find (key,
 228                                      value);
 229 }
 230
 231 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 232 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key)
 233 {
 234   return this->implementation_.find (key);
 235 }
 236
 237 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 238 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key)
 239 {
 240   return this->implementation_.unbind (key);
 241 }
 242
 243 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
 244 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key,
 245                                                                                      VALUE &value)
 246 {
 247   return this->implementation_.unbind (key,
 248                                        value);
 249 }
 250
 251 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
 252 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const
 253 {
 254   return this->implementation_.current_size ();
 255 }
 256
 257 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
 258 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const
 259 {
 260   return this->implementation_.total_size ();
 261 }
 262
 263 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> void
 264 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const
 265 {
 266 #if defined (ACE_HAS_DUMP)
 267   this->implementation_.dump ();
 268 #endif /* ACE_HAS_DUMP */
 269 }
 270
 271 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 272 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void)
 273 {
 274   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 275   ACE_NEW_RETURN (temp,
 276                   iterator_impl (this->implementation_.begin ()),
 277                   0);
 278   return temp;
 279 }
 280
 281 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 282 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void)
 283 {
 284   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 285   ACE_NEW_RETURN (temp,
 286                   iterator_impl (this->implementation_.end ()),
 287                   0);
 288   return temp;
 289 }
 290
 291 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 292 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void)
 293 {
 294   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 295   ACE_NEW_RETURN (temp,
 296                   reverse_iterator_impl (this->implementation_.rbegin ()),
 297                   0);
 298   return temp;
 299 }
 300
 301 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 302 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void)
 303 {
 304   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 305   ACE_NEW_RETURN (temp,
 306                   reverse_iterator_impl (this->implementation_.rend ()),
 307                   0);
 308   return temp;
 309 }
 310
 311 template <class T, class VALUE>
 312 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void)
 313 {
 314 }
 315
 316 template <class T, class VALUE> ACE_Iterator_Impl<T> *
 317 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const
 318 {
 319   ACE_Iterator_Impl<T> *temp = 0;
 320   ACE_NEW_RETURN (temp,
 321                   (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this),
 322                   0);
 323   return temp;
 324 }
 325
 326
 327 template <class T, class VALUE> int
 328 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
 329 {
 330   const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local
 331     = dynamic_cast<const ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE> &> (rhs);
 332
 333   return this->implementation_ == rhs_local.implementation_;
 334 }
 335
 336 template <class T, class VALUE> T
 337 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const
 338 {
 339   // The following syntax is necessary to work around certain broken compilers.
 340   // In particular, please do not prefix implementation_ with this->
 341   return T ((*implementation_).int_id_.first,
 342             (*implementation_).int_id_.second);
 343 }
 344
 345 template <class T, class VALUE> void
 346 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void)
 347 {
 348   ++this->implementation_;
 349 }
 350
 351 template <class T, class VALUE> void
 352 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void)
 353 {
 354   --this->implementation_;
 355 }
 356
 357 template <class T, class VALUE>
 358 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void)
 359 {
 360 }
 361
 362 template <class T, class VALUE> ACE_Reverse_Iterator_Impl<T> *
 363 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const
 364 {
 365   ACE_Reverse_Iterator_Impl<T> *temp = 0;
 366   ACE_NEW_RETURN (temp,
 367                   (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this),
 368                   0);
 369   return temp;
 370 }
 371
 372
 373 template <class T, class VALUE> int
 374 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
 375 {
 376   const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local
 377     = dynamic_cast<const ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE> &> (rhs);
 378
 379   return this->implementation_ == rhs_local.implementation_;
 380 }
 381
 382 template <class T, class VALUE> T
 383 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const
 384 {
 385   // The following syntax is necessary to work around certain broken compilers.
 386   // In particular, please do not prefix implementation_ with this->
 387   return T ((*implementation_).int_id_.first,
 388             (*implementation_).int_id_.second);
 389 }
 390
 391 template <class T, class VALUE> void
 392 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void)
 393 {
 394   ++this->implementation_;
 395 }
 396
 397 template <class T, class VALUE> void
 398 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void)
 399 {
 400   --this->implementation_;
 401 }
 402
 403 template <class KEY, class VALUE, class KEY_ADAPTER>
 404 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void)
 405 {
 406 }
 407
 408 template <class KEY, class VALUE, class KEY_ADAPTER> int
 409 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length,
 410                                                                ACE_Allocator *alloc)
 411 {
 412   return this->implementation_.open (length,
 413                                      alloc);
 414 }
 415
 416 template <class KEY, class VALUE, class KEY_ADAPTER> int
 417 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void)
 418 {
 419   return this->implementation_.close ();
 420 }
 421
 422 template <class KEY, class VALUE, class KEY_ADAPTER> int
 423 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &,
 424                                                                const VALUE &)
 425 {
 426   ACE_NOTSUP_RETURN (-1);
 427 }
 428
 429 template <class KEY, class VALUE, class KEY_ADAPTER> int
 430 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value,
 431                                                                           KEY &key)
 432 {
 433   // Reserve a slot and create an active key.
 434   expanded_value *internal_value = 0;
 435   ACE_Active_Map_Manager_Key active_key;
 436   int result = this->implementation_.bind (active_key,
 437                                            internal_value);
 438   if (result == 0)
 439     {
 440       // Encode the active key and the existing user key into key part
 441       // of <expanded_value>.
 442       result = this->key_adapter_.encode (key,
 443                                           active_key,
 444                                           internal_value->first);
 445       if (result == 0)
 446         {
 447           // Copy user value into <expanded_value>.
 448           internal_value->second = value;
 449           // Copy new, modified key back to the user key.
 450           key = internal_value->first;
 451         }
 452       else
 453         {
 454           // In case of errors, unbind from map.
 455           this->implementation_.unbind (active_key);
 456         }
 457     }
 458
 459   return result;
 460 }
 461
 462 template <class KEY, class VALUE, class KEY_ADAPTER> int
 463 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &)
 464 {
 465   ACE_NOTSUP_RETURN (-1);
 466 }
 467
 468 template <class KEY, class VALUE, class KEY_ADAPTER> int
 469 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value,
 470                                                                           KEY &key)
 471 {
 472   // Reserve a slot and create an active key.
 473   expanded_value *internal_value = 0;
 474   ACE_Active_Map_Manager_Key active_key;
 475   int result = this->implementation_.bind (active_key,
 476                                            internal_value);
 477   if (result == 0)
 478     {
 479       // Encode the active key into key part of <expanded_value>.
 480       result = this->key_adapter_.encode (internal_value->first,
 481                                           active_key,
 482                                           internal_value->first);
 483       if (result == 0)
 484         {
 485           // Copy user value into <expanded_value>.
 486           internal_value->second = value;
 487           // Copy new, modified key to the user key.
 488           key = internal_value->first;
 489         }
 490       else
 491         {
 492           // In case of errors, unbind from map.
 493           this->implementation_.unbind (active_key);
 494         }
 495     }
 496
 497   return result;
 498 }
 499
 500 template <class KEY, class VALUE, class KEY_ADAPTER> int
 501 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value)
 502 {
 503   // Reserve a slot and create an active key.
 504   expanded_value *internal_value = 0;
 505   ACE_Active_Map_Manager_Key active_key;
 506   int result = this->implementation_.bind (active_key,
 507                                            internal_value);
 508   if (result == 0)
 509     {
 510       // Encode the active key into key part of <expanded_value>.
 511       result = this->key_adapter_.encode (internal_value->first,
 512                                           active_key,
 513                                           internal_value->first);
 514       if (result == 0)
 515         {
 516           // Copy user value into <expanded_value>.
 517           internal_value->second = value;
 518         }
 519       else
 520         {
 521           // In case of errors, unbind from map.
 522           this->implementation_.unbind (active_key);
 523         }
 524     }
 525
 526   return result;
 527 }
 528
 529 template <class KEY, class VALUE, class KEY_ADAPTER> int
 530 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key,
 531                                                                       KEY &original_key)
 532 {
 533   // Ask the <key_adapter_> to help out with recovering the original
 534   // user key, since it was the one that encode it in the first place.
 535   return this->key_adapter_.decode (modified_key,
 536                                     original_key);
 537 }
 538
 539 template <class KEY, class VALUE, class KEY_ADAPTER> int
 540 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
 541                                                                expanded_value *&internal_value)
 542 {
 543   // Ask the <key_adapter_> to recover the active key.
 544   ACE_Active_Map_Manager_Key active_key;
 545   int result = this->key_adapter_.decode (key,
 546                                           active_key);
 547   if (result == 0)
 548     {
 549       // Find recovered active key in map.
 550       result = this->implementation_.find (active_key,
 551                                            internal_value);
 552     }
 553
 554   return result;
 555 }
 556
 557 template <class KEY, class VALUE, class KEY_ADAPTER> int
 558 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
 559                                                                VALUE &value)
 560 {
 561   expanded_value *internal_value = 0;
 562   int result = this->find (key,
 563                            internal_value);
 564
 565   if (result == 0)
 566     {
 567       // Copy value.
 568       value = internal_value->second;
 569     }
 570
 571   return result;
 572 }
 573
 574 template <class KEY, class VALUE, class KEY_ADAPTER> int
 575 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key)
 576 {
 577   expanded_value *internal_value = 0;
 578   return this->find (key,
 579                      internal_value);
 580 }
 581
 582 template <class KEY, class VALUE, class KEY_ADAPTER> int
 583 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
 584                                                                  const VALUE &value)
 585 {
 586   expanded_value *internal_value = 0;
 587   int result = this->find (key,
 588                            internal_value);
 589
 590   if (result == 0)
 591     {
 592       // Reset value.
 593       internal_value->second = value;
 594     }
 595
 596   return result;
 597 }
 598
 599 template <class KEY, class VALUE, class KEY_ADAPTER> int
 600 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
 601                                                                  const VALUE &value,
 602                                                                  VALUE &old_value)
 603 {
 604   expanded_value *internal_value = 0;
 605   int result = this->find (key,
 606                            internal_value);
 607
 608   if (result == 0)
 609     {
 610       // Copy old value.
 611       old_value = internal_value->second;
 612
 613       // Reset to new value.
 614       internal_value->second = value;
 615     }
 616
 617   return result;
 618 }
 619
 620 template <class KEY, class VALUE, class KEY_ADAPTER> int
 621 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
 622                                                                  const VALUE &value,
 623                                                                  KEY &old_key,
 624                                                                  VALUE &old_value)
 625 {
 626   expanded_value *internal_value = 0;
 627   int result = this->find (key,
 628                            internal_value);
 629
 630   if (result == 0)
 631     {
 632       // Copy old key and value.
 633       old_key = internal_value->first;
 634       old_value = internal_value->second;
 635
 636       // Reset to new value.
 637       internal_value->second = value;
 638     }
 639
 640   return result;
 641 }
 642
 643 template <class KEY, class VALUE, class KEY_ADAPTER> int
 644 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &,
 645                                                                   VALUE &)
 646 {
 647   ACE_NOTSUP_RETURN (-1);
 648 }
 649
 650 template <class KEY, class VALUE, class KEY_ADAPTER> int
 651 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
 652                                                                  expanded_value *&internal_value)
 653 {
 654   // Ask the <key_adapter_> to recover the active key.
 655   ACE_Active_Map_Manager_Key active_key;
 656   int result = this->key_adapter_.decode (key,
 657                                           active_key);
 658   if (result == 0)
 659     {
 660       // Unbind recovered active key from map.
 661       result = this->implementation_.unbind (active_key,
 662                                              internal_value);
 663     }
 664
 665   return result;
 666 }
 667
 668 template <class KEY, class VALUE, class KEY_ADAPTER> int
 669 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key)
 670 {
 671   expanded_value *internal_value = 0;
 672   return this->unbind (key,
 673                        internal_value);
 674 }
 675
 676 template <class KEY, class VALUE, class KEY_ADAPTER> int
 677 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
 678                                                                  VALUE &value)
 679 {
 680   expanded_value *internal_value = 0;
 681   int result = this->unbind (key,
 682                              internal_value);
 683
 684   if (result == 0)
 685     {
 686       // Copy value.
 687       value = internal_value->second;
 688     }
 689
 690   return result;
 691 }
 692
 693 template <class KEY, class VALUE, class KEY_ADAPTER> size_t
 694 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const
 695 {
 696   return this->implementation_.current_size ();
 697 }
 698
 699 template <class KEY, class VALUE, class KEY_ADAPTER> size_t
 700 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const
 701 {
 702   return this->implementation_.total_size ();
 703 }
 704
 705 template <class KEY, class VALUE, class KEY_ADAPTER> void
 706 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const
 707 {
 708 #if defined (ACE_HAS_DUMP)
 709   this->implementation_.dump ();
 710 #endif /* ACE_HAS_DUMP */
 711 }
 712
 713 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 714 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void)
 715 {
 716   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 717   ACE_NEW_RETURN (temp,
 718                   iterator_impl (this->implementation_.begin ()),
 719                   0);
 720   return temp;
 721 }
 722
 723 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 724 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void)
 725 {
 726   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 727   ACE_NEW_RETURN (temp,
 728                   iterator_impl (this->implementation_.end ()),
 729                   0);
 730   return temp;
 731 }
 732
 733 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 734 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void)
 735 {
 736   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 737   ACE_NEW_RETURN (temp,
 738                   reverse_iterator_impl (this->implementation_.rbegin ()),
 739                   0);
 740   return temp;
 741 }
 742
 743 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
 744 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void)
 745 {
 746   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
 747   ACE_NEW_RETURN (temp,
 748                   reverse_iterator_impl (this->implementation_.rend ()),
 749                   0);
 750   return temp;
 751 }
 752
 753 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
 754 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void)
 755 {
 756 }
 757
 758 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Iterator_Impl<T> *
 759 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
 760 {
 761   ACE_Iterator_Impl<T> *temp = 0;
 762   ACE_NEW_RETURN (temp,
 763                   (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
 764                   0);
 765   return temp;
 766 }
 767
 768
 769 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
 770 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const
 771 {
 772   const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
 773     = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);
 774
 775   return this->implementation_ == rhs_local.implementation_;
 776 }
 777
 778 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
 779 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
 780 {
 781   // The following syntax is necessary to work around certain broken compilers.
 782   // In particular, please do not prefix implementation_ with this->
 783   return T ((*implementation_).ext_id_,
 784             (*implementation_).int_id_);
 785 }
 786
 787 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
 788 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
 789 {
 790   ++this->implementation_;
 791 }
 792
 793 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
 794 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
 795 {
 796   --this->implementation_;
 797 }
 798
 799 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
 800 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void)
 801 {
 802 }
 803
 804 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Reverse_Iterator_Impl<T> *
 805 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
 806 {
 807   ACE_Reverse_Iterator_Impl<T> *temp = 0;
 808   ACE_NEW_RETURN (temp,
 809                   (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
 810                   0);
 811   return temp;
 812 }
 813
 814
 815 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
 816 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
 817 {
 818   const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
 819     = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);
 820
 821   return this->implementation_ == rhs_local.implementation_;
 822 }
 823
 824 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
 825 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
 826 {
 827   // The following syntax is necessary to work around certain broken compilers.
 828   // In particular, please do not prefix implementation_ with this->
 829   return T ((*implementation_).ext_id_,
 830             (*implementation_).int_id_);
 831 }
 832
 833 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
 834 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
 835 {
 836   ++this->implementation_;
 837 }
 838
 839 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
 840 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
 841 {
 842   --this->implementation_;
 843 }
 844
 845 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
 846 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void)
 847 {
 848 }
 849
 850 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 851 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length,
 852                                                                                           ACE_Allocator *alloc)
 853 {
 854   return this->implementation_.open (length,
 855                                      alloc);
 856 }
 857
 858 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 859 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void)
 860 {
 861   return this->implementation_.close ();
 862 }
 863
 864 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 865 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key,
 866                                                                                           const VALUE &value)
 867 {
 868   return this->implementation_.bind (key,
 869                                      value);
 870 }
 871
 872 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 873 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
 874                                                                                                      KEY &key)
 875 {
 876   return this->implementation_.bind (key,
 877                                      value);
 878 }
 879
 880 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 881 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key)
 882 {
 883   // Invoke the user specified key generation functor.
 884   return this->key_generator_ (key);
 885 }
 886
 887 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 888 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value,
 889                                                                                                      KEY &key)
 890 {
 891   // Invoke the user specified key generation functor.
 892   int result = this->key_generator_ (key);
 893
 894   if (result == 0)
 895     {
 896       // Try to add.
 897       result = this->implementation_.bind (key,
 898                                            value);
 899     }
 900
 901   return result;
 902 }
 903
 904 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 905 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value)
 906 {
 907   KEY key;
 908   return this->bind_create_key (value,
 909                                 key);
 910 }
 911
 912 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 913 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key,
 914                                                                                                  KEY &original_key)
 915 {
 916   original_key = modified_key;
 917   return 0;
 918 }
 919
 920 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 921 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
 922                                                                                             const VALUE &value)
 923 {
 924   return this->implementation_.rebind (key,
 925                                        value);
 926 }
 927
 928 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 929 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
 930                                                                                             const VALUE &value,
 931                                                                                             VALUE &old_value)
 932 {
 933   return this->implementation_.rebind (key,
 934                                        value,
 935                                        old_value);
 936 }
 937
 938 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 939 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
 940                                                                                             const VALUE &value,
 941                                                                                             KEY &old_key,
 942                                                                                             VALUE &old_value)
 943 {
 944   return this->implementation_.rebind (key,
 945                                        value,
 946                                        old_key,
 947                                        old_value);
 948 }
 949
 950 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 951 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key,
 952                                                                                              VALUE &value)
 953 {
 954   return this->implementation_.trybind (key,
 955                                         value);
 956 }
 957
 958 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 959 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key,
 960                                                                                           VALUE &value)
 961 {
 962   return this->implementation_.find (key,
 963                                      value);
 964 }
 965
 966 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 967 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key)
 968 {
 969   return this->implementation_.find (key);
 970 }
 971
 972 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 973 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key)
 974 {
 975   return this->implementation_.unbind (key);
 976 }
 977
 978 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
 979 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key,
 980                                                                                             VALUE &value)
 981 {
 982   return this->implementation_.unbind (key,
 983                                        value);
 984 }
 985
 986 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
 987 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const
 988 {
 989   return this->implementation_.current_size ();
 990 }
 991
 992 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
 993 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const
 994 {
 995   return this->implementation_.total_size ();
 996 }
 997
 998 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> void
 999 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const
1000 {
1001 #if defined (ACE_HAS_DUMP)
1002   this->implementation_.dump ();
1003 #endif /* ACE_HAS_DUMP */
1004 }
1005
1006 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1007 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void)
1008 {
1009   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1010   ACE_NEW_RETURN (temp,
1011                   iterator_impl (this->implementation_.begin ()),
1012                   0);
1013   return temp;
1014 }
1015
1016 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1017 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void)
1018 {
1019   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1020   ACE_NEW_RETURN (temp,
1021                   iterator_impl (this->implementation_.end ()),
1022                   0);
1023   return temp;
1024 }
1025
1026 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1027 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void)
1028 {
1029   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1030   ACE_NEW_RETURN (temp,
1031                   reverse_iterator_impl (this->implementation_.rbegin ()),
1032                   0);
1033   return temp;
1034 }
1035
1036 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1037 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void)
1038 {
1039   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1040   ACE_NEW_RETURN (temp,
1041                   reverse_iterator_impl (this->implementation_.rend ()),
1042                   0);
1043   return temp;
1044 }
1045
1046 template <class T, class KEY, class VALUE>
1047 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void)
1048 {
1049 }
1050
1051 template <class T, class KEY, class VALUE> ACE_Iterator_Impl<T> *
1052 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
1053 {
1054   ACE_Iterator_Impl<T> *temp = 0;
1055   ACE_NEW_RETURN (temp,
1056                   (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this),
1057                   0);
1058   return temp;
1059 }
1060
1061
1062 template <class T, class KEY, class VALUE> int
1063 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
1064 {
1065   const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local
1066     = dynamic_cast<const ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE> &> (rhs);
1067
1068   return this->implementation_ == rhs_local.implementation_;
1069 }
1070
1071 template <class T, class KEY, class VALUE> T
1072 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const
1073 {
1074   // The following syntax is necessary to work around certain broken compilers.
1075   // In particular, please do not prefix implementation_ with this->
1076   return T ((*implementation_).ext_id_,
1077             (*implementation_).int_id_);
1078 }
1079
1080 template <class T, class KEY, class VALUE> void
1081 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
1082 {
1083   ++this->implementation_;
1084 }
1085
1086 template <class T, class KEY, class VALUE> void
1087 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
1088 {
1089   --this->implementation_;
1090 }
1091
1092 template <class T, class KEY, class VALUE>
1093 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void)
1094 {
1095 }
1096
1097 template <class T, class KEY, class VALUE> ACE_Reverse_Iterator_Impl<T> *
1098 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
1099 {
1100   ACE_Reverse_Iterator_Impl<T> *temp = 0;
1101   ACE_NEW_RETURN (temp,
1102                   (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this),
1103                   0);
1104   return temp;
1105 }
1106
1107
1108 template <class T, class KEY, class VALUE> int
1109 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
1110 {
1111   const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local
1112     = dynamic_cast<const ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE> &> (rhs);
1113
1114   return this->implementation_ == rhs_local.implementation_;
1115 }
1116
1117 template <class T, class KEY, class VALUE> T
1118 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const
1119 {
1120   // The following syntax is necessary to work around certain broken compilers.
1121   // In particular, please do not prefix implementation_ with this->
1122   return T ((*implementation_).ext_id_,
1123             (*implementation_).int_id_);
1124 }
1125
1126 template <class T, class KEY, class VALUE> void
1127 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
1128 {
1129   ++this->implementation_;
1130 }
1131
1132 template <class T, class KEY, class VALUE> void
1133 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
1134 {
1135   --this->implementation_;
1136 }
1137
1138 template <class KEY, class VALUE, class KEY_GENERATOR>
1139 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void)
1140 {
1141 }
1142
1143 template <class KEY, class VALUE, class KEY_GENERATOR> int
1144 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length,
1145                                                           ACE_Allocator *alloc)
1146 {
1147   return this->implementation_.open (length,
1148                                      alloc);
1149 }
1150
1151 template <class KEY, class VALUE, class KEY_GENERATOR> int
1152 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void)
1153 {
1154   return this->implementation_.close ();
1155 }
1156
1157 template <class KEY, class VALUE, class KEY_GENERATOR> int
1158 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key,
1159                                                           const VALUE &value)
1160 {
1161   return this->implementation_.bind (key,
1162                                      value);
1163 }
1164
1165 template <class KEY, class VALUE, class KEY_GENERATOR> int
1166 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
1167                                                                      KEY &key)
1168 {
1169   return this->implementation_.bind (key,
1170                                      value);
1171 }
1172
1173 template <class KEY, class VALUE, class KEY_GENERATOR> int
1174 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key)
1175 {
1176   // Invoke the user specified key generation functor.
1177   return this->key_generator_ (key);
1178 }
1179
1180 template <class KEY, class VALUE, class KEY_GENERATOR> int
1181 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value,
1182                                                                      KEY &key)
1183 {
1184   // Invoke the user specified key generation functor.
1185   int result = this->key_generator_ (key);
1186
1187   if (result == 0)
1188     {
1189       // Try to add.
1190       result = this->implementation_.bind (key,
1191                                            value);
1192     }
1193
1194   return result;
1195 }
1196
1197 template <class KEY, class VALUE, class KEY_GENERATOR> int
1198 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value)
1199 {
1200   KEY key;
1201   return this->bind_create_key (value,
1202                                 key);
1203 }
1204
1205 template <class KEY, class VALUE, class KEY_GENERATOR> int
1206 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key,
1207                                                                  KEY &original_key)
1208 {
1209   original_key = modified_key;
1210   return 0;
1211 }
1212
1213 template <class KEY, class VALUE, class KEY_GENERATOR> int
1214 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
1215                                                             const VALUE &value)
1216 {
1217   return this->implementation_.rebind (key,
1218                                        value);
1219 }
1220
1221 template <class KEY, class VALUE, class KEY_GENERATOR> int
1222 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
1223                                                             const VALUE &value,
1224                                                             VALUE &old_value)
1225 {
1226   return this->implementation_.rebind (key,
1227                                        value,
1228                                        old_value);
1229 }
1230
1231 template <class KEY, class VALUE, class KEY_GENERATOR> int
1232 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
1233                                                             const VALUE &value,
1234                                                             KEY &old_key,
1235                                                             VALUE &old_value)
1236 {
1237   return this->implementation_.rebind (key,
1238                                        value,
1239                                        old_key,
1240                                        old_value);
1241 }
1242
1243 template <class KEY, class VALUE, class KEY_GENERATOR> int
1244 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key,
1245                                                              VALUE &value)
1246 {
1247   return this->implementation_.trybind (key,
1248                                         value);
1249 }
1250
1251 template <class KEY, class VALUE, class KEY_GENERATOR> int
1252 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key,
1253                                                           VALUE &value)
1254 {
1255   return this->implementation_.find (key,
1256                                      value);
1257 }
1258
1259 template <class KEY, class VALUE, class KEY_GENERATOR> int
1260 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key)
1261 {
1262   return this->implementation_.find (key);
1263 }
1264
1265 template <class KEY, class VALUE, class KEY_GENERATOR> int
1266 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key)
1267 {
1268   return this->implementation_.unbind (key);
1269 }
1270
1271 template <class KEY, class VALUE, class KEY_GENERATOR> int
1272 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key,
1273                                                             VALUE &value)
1274 {
1275   return this->implementation_.unbind (key,
1276                                        value);
1277 }
1278
1279 template <class KEY, class VALUE, class KEY_GENERATOR> size_t
1280 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const
1281 {
1282   return this->implementation_.current_size ();
1283 }
1284
1285 template <class KEY, class VALUE, class KEY_GENERATOR> size_t
1286 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const
1287 {
1288   return this->implementation_.total_size ();
1289 }
1290
1291 template <class KEY, class VALUE, class KEY_GENERATOR> void
1292 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const
1293 {
1294 #if defined (ACE_HAS_DUMP)
1295   this->implementation_.dump ();
1296 #endif /* ACE_HAS_DUMP */
1297 }
1298
1299 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1300 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void)
1301 {
1302   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1303   ACE_NEW_RETURN (temp,
1304                   iterator_impl (this->implementation_.begin ()),
1305                   0);
1306   return temp;
1307 }
1308
1309 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1310 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void)
1311 {
1312   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1313   ACE_NEW_RETURN (temp,
1314                   iterator_impl (this->implementation_.end ()),
1315                   0);
1316   return temp;
1317 }
1318
1319 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1320 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void)
1321 {
1322   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1323   ACE_NEW_RETURN (temp,
1324                   reverse_iterator_impl (this->implementation_.rbegin ()),
1325                   0);
1326   return temp;
1327 }
1328
1329 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
1330 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void)
1331 {
1332   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
1333   ACE_NEW_RETURN (temp,
1334                   reverse_iterator_impl (this->implementation_.rend ()),
1335                   0);
1336   return temp;
1337 }
1338
1339 ACE_END_VERSIONED_NAMESPACE_DECL
1340
1341 #endif /* ACE_MAP_T_CPP */