dep/ACE_wrappers/ace/Map_T.cpp

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