Map_T.cpp

Go to the documentation of this file.
00001 // Map_T.cpp,v 4.5 2005/10/28 16:14:53 ossama Exp
00002 
00003 #ifndef ACE_MAP_T_CPP
00004 #define ACE_MAP_T_CPP
00005 
00006 #include "ace/Map_T.h"
00007 
00008 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00009 # pragma once
00010 #endif /* ACE_LACKS_PRAGMA_ONCE */
00011 
00012 #if !defined (__ACE_INLINE__)
00013 #include "ace/Map_T.inl"
00014 #endif /* __ACE_INLINE__ */
00015 
00016 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00017 
00018 template <class KEY, class VALUE>
00019 ACE_Map<KEY, VALUE>::~ACE_Map (void)
00020 {
00021 }
00022 
00023 template <class T>
00024 ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void)
00025 {
00026 }
00027 
00028 template <class T>
00029 ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void)
00030 {
00031 }
00032 
00033 template <class T, class IMPLEMENTATION, class ENTRY>
00034 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void)
00035 {
00036 }
00037 
00038 
00039 template <class T, class IMPLEMENTATION, class ENTRY> ACE_Iterator_Impl<T> *
00040 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
00041 {
00042   ACE_Iterator_Impl<T> *temp = 0;
00043   ACE_NEW_RETURN (temp,
00044                   (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
00045                   0);
00046   return temp;
00047 }
00048 
00049 template <class T, class IMPLEMENTATION, class ENTRY> int
00050 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const
00051 {
00052   const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
00053     = dynamic_cast<const ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);
00054 
00055   return this->implementation_ == rhs_local.implementation_;
00056 }
00057 
00058 template <class T, class IMPLEMENTATION, class ENTRY> T
00059 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
00060 {
00061   ENTRY &entry = *this->implementation_;
00062   return T (entry.ext_id_,
00063             entry.int_id_);
00064 }
00065 
00066 template <class T, class IMPLEMENTATION, class ENTRY> void
00067 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
00068 {
00069   ++this->implementation_;
00070 }
00071 
00072 template <class T, class IMPLEMENTATION, class ENTRY> void
00073 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
00074 {
00075   --this->implementation_;
00076 }
00077 
00078 template <class T, class IMPLEMENTATION, class ENTRY>
00079 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void)
00080 {
00081 }
00082 
00083 template <class T, class IMPLEMENTATION, class ENTRY> ACE_Reverse_Iterator_Impl<T> *
00084 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
00085 {
00086   ACE_Reverse_Iterator_Impl<T> *temp = 0;
00087   ACE_NEW_RETURN (temp,
00088                   (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
00089                   0);
00090   return temp;
00091 }
00092 
00093 
00094 template <class T, class IMPLEMENTATION, class ENTRY> int
00095 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
00096 {
00097   const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
00098     = dynamic_cast<const ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);
00099 
00100   return this->implementation_ == rhs_local.implementation_;
00101 }
00102 
00103 template <class T, class IMPLEMENTATION, class ENTRY> T
00104 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
00105 {
00106   ENTRY &entry = *this->implementation_;
00107   return T (entry.ext_id_,
00108             entry.int_id_);
00109 }
00110 
00111 template <class T, class IMPLEMENTATION, class ENTRY> void
00112 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
00113 {
00114   ++this->implementation_;
00115 }
00116 
00117 template <class T, class IMPLEMENTATION, class ENTRY> void
00118 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
00119 {
00120   --this->implementation_;
00121 }
00122 
00123 
00124 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY>
00125 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void)
00126 {
00127 }
00128 
00129 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00130 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length,
00131                                                                                    ACE_Allocator *alloc)
00132 {
00133   return this->implementation_.open (length,
00134                                      alloc);
00135 }
00136 
00137 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00138 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void)
00139 {
00140   return this->implementation_.close ();
00141 }
00142 
00143 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00144 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key,
00145                                                                                    const VALUE &value)
00146 {
00147   return this->implementation_.bind (key,
00148                                      value);
00149 }
00150 
00151 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00152 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value,
00153                                                                                               KEY &key)
00154 {
00155   return this->implementation_.bind_modify_key (value,
00156                                                 key);
00157 }
00158 
00159 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00160 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key)
00161 {
00162   return this->implementation_.create_key (key);
00163 }
00164 
00165 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00166 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value,
00167                                                                                               KEY &key)
00168 {
00169   return this->implementation_.bind_create_key (value,
00170                                                 key);
00171 }
00172 
00173 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00174 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value)
00175 {
00176   return this->implementation_.bind_create_key (value);
00177 }
00178 
00179 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00180 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key,
00181                                                                                           KEY &original_key)
00182 {
00183   return this->implementation_.recover_key (modified_key,
00184                                             original_key);
00185 }
00186 
00187 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00188 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00189                                                                                      const VALUE &value)
00190 {
00191   return this->implementation_.rebind (key,
00192                                        value);
00193 }
00194 
00195 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00196 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00197                                                                                      const VALUE &value,
00198                                                                                      VALUE &old_value)
00199 {
00200   return this->implementation_.rebind (key,
00201                                        value,
00202                                        old_value);
00203 }
00204 
00205 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00206 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00207                                                                                      const VALUE &value,
00208                                                                                      KEY &old_key,
00209                                                                                      VALUE &old_value)
00210 {
00211   return this->implementation_.rebind (key,
00212                                        value,
00213                                        old_key,
00214                                        old_value);
00215 }
00216 
00217 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00218 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key,
00219                                                                                       VALUE &value)
00220 {
00221   return this->implementation_.trybind (key,
00222                                         value);
00223 }
00224 
00225 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00226 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key,
00227                                                                                    VALUE &value)
00228 {
00229   return this->implementation_.find (key,
00230                                      value);
00231 }
00232 
00233 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00234 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key)
00235 {
00236   return this->implementation_.find (key);
00237 }
00238 
00239 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00240 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key)
00241 {
00242   return this->implementation_.unbind (key);
00243 }
00244 
00245 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
00246 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key,
00247                                                                                      VALUE &value)
00248 {
00249   return this->implementation_.unbind (key,
00250                                        value);
00251 }
00252 
00253 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
00254 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const
00255 {
00256   return this->implementation_.current_size ();
00257 }
00258 
00259 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
00260 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const
00261 {
00262   return this->implementation_.total_size ();
00263 }
00264 
00265 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> void
00266 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const
00267 {
00268 #if defined (ACE_HAS_DUMP)
00269   this->implementation_.dump ();
00270 #endif /* ACE_HAS_DUMP */
00271 }
00272 
00273 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00274 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void)
00275 {
00276   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00277   ACE_NEW_RETURN (temp,
00278                   iterator_impl (this->implementation_.begin ()),
00279                   0);
00280   return temp;
00281 }
00282 
00283 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00284 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void)
00285 {
00286   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00287   ACE_NEW_RETURN (temp,
00288                   iterator_impl (this->implementation_.end ()),
00289                   0);
00290   return temp;
00291 }
00292 
00293 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00294 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void)
00295 {
00296   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00297   ACE_NEW_RETURN (temp,
00298                   reverse_iterator_impl (this->implementation_.rbegin ()),
00299                   0);
00300   return temp;
00301 }
00302 
00303 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00304 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void)
00305 {
00306   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00307   ACE_NEW_RETURN (temp,
00308                   reverse_iterator_impl (this->implementation_.rend ()),
00309                   0);
00310   return temp;
00311 }
00312 
00313 template <class T, class VALUE>
00314 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void)
00315 {
00316 }
00317 
00318 template <class T, class VALUE> ACE_Iterator_Impl<T> *
00319 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const
00320 {
00321   ACE_Iterator_Impl<T> *temp = 0;
00322   ACE_NEW_RETURN (temp,
00323                   (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this),
00324                   0);
00325   return temp;
00326 }
00327 
00328 
00329 template <class T, class VALUE> int
00330 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
00331 {
00332   const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local
00333     = dynamic_cast<const ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE> &> (rhs);
00334 
00335   return this->implementation_ == rhs_local.implementation_;
00336 }
00337 
00338 template <class T, class VALUE> T
00339 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const
00340 {
00341   // The following syntax is necessary to work around certain broken compilers.
00342   // In particular, please do not prefix implementation_ with this->
00343   return T ((*implementation_).int_id_.first (),
00344             (*implementation_).int_id_.second ());
00345 }
00346 
00347 template <class T, class VALUE> void
00348 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void)
00349 {
00350   ++this->implementation_;
00351 }
00352 
00353 template <class T, class VALUE> void
00354 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void)
00355 {
00356   --this->implementation_;
00357 }
00358 
00359 template <class T, class VALUE>
00360 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void)
00361 {
00362 }
00363 
00364 template <class T, class VALUE> ACE_Reverse_Iterator_Impl<T> *
00365 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const
00366 {
00367   ACE_Reverse_Iterator_Impl<T> *temp = 0;
00368   ACE_NEW_RETURN (temp,
00369                   (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this),
00370                   0);
00371   return temp;
00372 }
00373 
00374 
00375 template <class T, class VALUE> int
00376 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
00377 {
00378   const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local
00379     = dynamic_cast<const ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE> &> (rhs);
00380 
00381   return this->implementation_ == rhs_local.implementation_;
00382 }
00383 
00384 template <class T, class VALUE> T
00385 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const
00386 {
00387   // The following syntax is necessary to work around certain broken compilers.
00388   // In particular, please do not prefix implementation_ with this->
00389   return T ((*implementation_).int_id_.first (),
00390             (*implementation_).int_id_.second ());
00391 }
00392 
00393 template <class T, class VALUE> void
00394 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void)
00395 {
00396   ++this->implementation_;
00397 }
00398 
00399 template <class T, class VALUE> void
00400 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void)
00401 {
00402   --this->implementation_;
00403 }
00404 
00405 template <class KEY, class VALUE, class KEY_ADAPTER>
00406 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void)
00407 {
00408 }
00409 
00410 template <class KEY, class VALUE, class KEY_ADAPTER> int
00411 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length,
00412                                                                ACE_Allocator *alloc)
00413 {
00414   return this->implementation_.open (length,
00415                                      alloc);
00416 }
00417 
00418 template <class KEY, class VALUE, class KEY_ADAPTER> int
00419 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void)
00420 {
00421   return this->implementation_.close ();
00422 }
00423 
00424 template <class KEY, class VALUE, class KEY_ADAPTER> int
00425 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &,
00426                                                                const VALUE &)
00427 {
00428   ACE_NOTSUP_RETURN (-1);
00429 }
00430 
00431 template <class KEY, class VALUE, class KEY_ADAPTER> int
00432 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value,
00433                                                                           KEY &key)
00434 {
00435   // Reserve a slot and create an active key.
00436   expanded_value *internal_value = 0;
00437   ACE_Active_Map_Manager_Key active_key;
00438   int result = this->implementation_.bind (active_key,
00439                                            internal_value);
00440   if (result == 0)
00441     {
00442       // Encode the active key and the existing user key into key part
00443       // of <expanded_value>.
00444       result = this->key_adapter_.encode (key,
00445                                           active_key,
00446                                           internal_value->first ());
00447       if (result == 0)
00448         {
00449           // Copy user value into <expanded_value>.
00450           internal_value->second (value);
00451           // Copy new, modified key back to the user key.
00452           key = internal_value->first ();
00453         }
00454       else
00455         {
00456           // In case of errors, unbind from map.
00457           this->implementation_.unbind (active_key);
00458         }
00459     }
00460 
00461   return result;
00462 }
00463 
00464 template <class KEY, class VALUE, class KEY_ADAPTER> int
00465 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &)
00466 {
00467   ACE_NOTSUP_RETURN (-1);
00468 }
00469 
00470 template <class KEY, class VALUE, class KEY_ADAPTER> int
00471 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value,
00472                                                                           KEY &key)
00473 {
00474   // Reserve a slot and create an active key.
00475   expanded_value *internal_value = 0;
00476   ACE_Active_Map_Manager_Key active_key;
00477   int result = this->implementation_.bind (active_key,
00478                                            internal_value);
00479   if (result == 0)
00480     {
00481       // Encode the active key into key part of <expanded_value>.
00482       result = this->key_adapter_.encode (internal_value->first (),
00483                                           active_key,
00484                                           internal_value->first ());
00485       if (result == 0)
00486         {
00487           // Copy user value into <expanded_value>.
00488           internal_value->second (value);
00489           // Copy new, modified key to the user key.
00490           key = internal_value->first ();
00491         }
00492       else
00493         {
00494           // In case of errors, unbind from map.
00495           this->implementation_.unbind (active_key);
00496         }
00497     }
00498 
00499   return result;
00500 }
00501 
00502 template <class KEY, class VALUE, class KEY_ADAPTER> int
00503 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value)
00504 {
00505   // Reserve a slot and create an active key.
00506   expanded_value *internal_value = 0;
00507   ACE_Active_Map_Manager_Key active_key;
00508   int result = this->implementation_.bind (active_key,
00509                                            internal_value);
00510   if (result == 0)
00511     {
00512       // Encode the active key into key part of <expanded_value>.
00513       result = this->key_adapter_.encode (internal_value->first (),
00514                                           active_key,
00515                                           internal_value->first ());
00516       if (result == 0)
00517         {
00518           // Copy user value into <expanded_value>.
00519           internal_value->second (value);
00520         }
00521       else
00522         {
00523           // In case of errors, unbind from map.
00524           this->implementation_.unbind (active_key);
00525         }
00526     }
00527 
00528   return result;
00529 }
00530 
00531 template <class KEY, class VALUE, class KEY_ADAPTER> int
00532 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key,
00533                                                                       KEY &original_key)
00534 {
00535   // Ask the <key_adapter_> to help out with recovering the original
00536   // user key, since it was the one that encode it in the first place.
00537   return this->key_adapter_.decode (modified_key,
00538                                     original_key);
00539 }
00540 
00541 template <class KEY, class VALUE, class KEY_ADAPTER> int
00542 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
00543                                                                expanded_value *&internal_value)
00544 {
00545   // Ask the <key_adapter_> to recover the active key.
00546   ACE_Active_Map_Manager_Key active_key;
00547   int result = this->key_adapter_.decode (key,
00548                                           active_key);
00549   if (result == 0)
00550     {
00551       // Find recovered active key in map.
00552       result = this->implementation_.find (active_key,
00553                                            internal_value);
00554     }
00555 
00556   return result;
00557 }
00558 
00559 template <class KEY, class VALUE, class KEY_ADAPTER> int
00560 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
00561                                                                VALUE &value)
00562 {
00563   expanded_value *internal_value = 0;
00564   int result = this->find (key,
00565                            internal_value);
00566 
00567   if (result == 0)
00568     {
00569       // Copy value.
00570       value = internal_value->second ();
00571     }
00572 
00573   return result;
00574 }
00575 
00576 template <class KEY, class VALUE, class KEY_ADAPTER> int
00577 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key)
00578 {
00579   expanded_value *internal_value = 0;
00580   return this->find (key,
00581                      internal_value);
00582 }
00583 
00584 template <class KEY, class VALUE, class KEY_ADAPTER> int
00585 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00586                                                                  const VALUE &value)
00587 {
00588   expanded_value *internal_value = 0;
00589   int result = this->find (key,
00590                            internal_value);
00591 
00592   if (result == 0)
00593     {
00594       // Reset value.
00595       internal_value->second (value);
00596     }
00597 
00598   return result;
00599 }
00600 
00601 template <class KEY, class VALUE, class KEY_ADAPTER> int
00602 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00603                                                                  const VALUE &value,
00604                                                                  VALUE &old_value)
00605 {
00606   expanded_value *internal_value = 0;
00607   int result = this->find (key,
00608                            internal_value);
00609 
00610   if (result == 0)
00611     {
00612       // Copy old value.
00613       old_value = internal_value->second ();
00614 
00615       // Reset to new value.
00616       internal_value->second (value);
00617     }
00618 
00619   return result;
00620 }
00621 
00622 template <class KEY, class VALUE, class KEY_ADAPTER> int
00623 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00624                                                                  const VALUE &value,
00625                                                                  KEY &old_key,
00626                                                                  VALUE &old_value)
00627 {
00628   expanded_value *internal_value = 0;
00629   int result = this->find (key,
00630                            internal_value);
00631 
00632   if (result == 0)
00633     {
00634       // Copy old key and value.
00635       old_key = internal_value->first ();
00636       old_value = internal_value->second ();
00637 
00638       // Reset to new value.
00639       internal_value->second (value);
00640     }
00641 
00642   return result;
00643 }
00644 
00645 template <class KEY, class VALUE, class KEY_ADAPTER> int
00646 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &,
00647                                                                   VALUE &)
00648 {
00649   ACE_NOTSUP_RETURN (-1);
00650 }
00651 
00652 template <class KEY, class VALUE, class KEY_ADAPTER> int
00653 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
00654                                                                  expanded_value *&internal_value)
00655 {
00656   // Ask the <key_adapter_> to recover the active key.
00657   ACE_Active_Map_Manager_Key active_key;
00658   int result = this->key_adapter_.decode (key,
00659                                           active_key);
00660   if (result == 0)
00661     {
00662       // Unbind recovered active key from map.
00663       result = this->implementation_.unbind (active_key,
00664                                              internal_value);
00665     }
00666 
00667   return result;
00668 }
00669 
00670 template <class KEY, class VALUE, class KEY_ADAPTER> int
00671 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key)
00672 {
00673   expanded_value *internal_value = 0;
00674   return this->unbind (key,
00675                        internal_value);
00676 }
00677 
00678 template <class KEY, class VALUE, class KEY_ADAPTER> int
00679 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
00680                                                                  VALUE &value)
00681 {
00682   expanded_value *internal_value = 0;
00683   int result = this->unbind (key,
00684                              internal_value);
00685 
00686   if (result == 0)
00687     {
00688       // Copy value.
00689       value = internal_value->second ();
00690     }
00691 
00692   return result;
00693 }
00694 
00695 template <class KEY, class VALUE, class KEY_ADAPTER> size_t
00696 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const
00697 {
00698   return this->implementation_.current_size ();
00699 }
00700 
00701 template <class KEY, class VALUE, class KEY_ADAPTER> size_t
00702 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const
00703 {
00704   return this->implementation_.total_size ();
00705 }
00706 
00707 template <class KEY, class VALUE, class KEY_ADAPTER> void
00708 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const
00709 {
00710 #if defined (ACE_HAS_DUMP)
00711   this->implementation_.dump ();
00712 #endif /* ACE_HAS_DUMP */
00713 }
00714 
00715 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00716 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void)
00717 {
00718   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00719   ACE_NEW_RETURN (temp,
00720                   iterator_impl (this->implementation_.begin ()),
00721                   0);
00722   return temp;
00723 }
00724 
00725 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00726 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void)
00727 {
00728   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00729   ACE_NEW_RETURN (temp,
00730                   iterator_impl (this->implementation_.end ()),
00731                   0);
00732   return temp;
00733 }
00734 
00735 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00736 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void)
00737 {
00738   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00739   ACE_NEW_RETURN (temp,
00740                   reverse_iterator_impl (this->implementation_.rbegin ()),
00741                   0);
00742   return temp;
00743 }
00744 
00745 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00746 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void)
00747 {
00748   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00749   ACE_NEW_RETURN (temp,
00750                   reverse_iterator_impl (this->implementation_.rend ()),
00751                   0);
00752   return temp;
00753 }
00754 
00755 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
00756 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void)
00757 {
00758 }
00759 
00760 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Iterator_Impl<T> *
00761 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
00762 {
00763   ACE_Iterator_Impl<T> *temp = 0;
00764   ACE_NEW_RETURN (temp,
00765                   (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
00766                   0);
00767   return temp;
00768 }
00769 
00770 
00771 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
00772 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const
00773 {
00774   const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
00775     = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);
00776 
00777   return this->implementation_ == rhs_local.implementation_;
00778 }
00779 
00780 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
00781 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
00782 {
00783   // The following syntax is necessary to work around certain broken compilers.
00784   // In particular, please do not prefix implementation_ with this->
00785   return T ((*implementation_).ext_id_,
00786             (*implementation_).int_id_);
00787 }
00788 
00789 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
00790 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
00791 {
00792   ++this->implementation_;
00793 }
00794 
00795 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
00796 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
00797 {
00798   --this->implementation_;
00799 }
00800 
00801 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
00802 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void)
00803 {
00804 }
00805 
00806 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Reverse_Iterator_Impl<T> *
00807 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
00808 {
00809   ACE_Reverse_Iterator_Impl<T> *temp = 0;
00810   ACE_NEW_RETURN (temp,
00811                   (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
00812                   0);
00813   return temp;
00814 }
00815 
00816 
00817 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
00818 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
00819 {
00820   const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
00821     = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);
00822 
00823   return this->implementation_ == rhs_local.implementation_;
00824 }
00825 
00826 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
00827 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
00828 {
00829   // The following syntax is necessary to work around certain broken compilers.
00830   // In particular, please do not prefix implementation_ with this->
00831   return T ((*implementation_).ext_id_,
00832             (*implementation_).int_id_);
00833 }
00834 
00835 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
00836 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
00837 {
00838   ++this->implementation_;
00839 }
00840 
00841 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
00842 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
00843 {
00844   --this->implementation_;
00845 }
00846 
00847 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
00848 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void)
00849 {
00850 }
00851 
00852 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00853 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length,
00854                                                                                           ACE_Allocator *alloc)
00855 {
00856   return this->implementation_.open (length,
00857                                      alloc);
00858 }
00859 
00860 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00861 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void)
00862 {
00863   return this->implementation_.close ();
00864 }
00865 
00866 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00867 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key,
00868                                                                                           const VALUE &value)
00869 {
00870   return this->implementation_.bind (key,
00871                                      value);
00872 }
00873 
00874 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00875 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
00876                                                                                                      KEY &key)
00877 {
00878   return this->implementation_.bind (key,
00879                                      value);
00880 }
00881 
00882 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00883 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key)
00884 {
00885   // Invoke the user specified key generation functor.
00886   return this->key_generator_ (key);
00887 }
00888 
00889 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00890 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value,
00891                                                                                                      KEY &key)
00892 {
00893   // Invoke the user specified key generation functor.
00894   int result = this->key_generator_ (key);
00895 
00896   if (result == 0)
00897     {
00898       // Try to add.
00899       result = this->implementation_.bind (key,
00900                                            value);
00901     }
00902 
00903   return result;
00904 }
00905 
00906 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00907 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value)
00908 {
00909   KEY key;
00910   return this->bind_create_key (value,
00911                                 key);
00912 }
00913 
00914 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00915 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key,
00916                                                                                                  KEY &original_key)
00917 {
00918   original_key = modified_key;
00919   return 0;
00920 }
00921 
00922 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00923 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
00924                                                                                             const VALUE &value)
00925 {
00926   return this->implementation_.rebind (key,
00927                                        value);
00928 }
00929 
00930 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00931 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
00932                                                                                             const VALUE &value,
00933                                                                                             VALUE &old_value)
00934 {
00935   return this->implementation_.rebind (key,
00936                                        value,
00937                                        old_value);
00938 }
00939 
00940 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00941 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
00942                                                                                             const VALUE &value,
00943                                                                                             KEY &old_key,
00944                                                                                             VALUE &old_value)
00945 {
00946   return this->implementation_.rebind (key,
00947                                        value,
00948                                        old_key,
00949                                        old_value);
00950 }
00951 
00952 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00953 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key,
00954                                                                                              VALUE &value)
00955 {
00956   return this->implementation_.trybind (key,
00957                                         value);
00958 }
00959 
00960 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00961 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key,
00962                                                                                           VALUE &value)
00963 {
00964   return this->implementation_.find (key,
00965                                      value);
00966 }
00967 
00968 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00969 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key)
00970 {
00971   return this->implementation_.find (key);
00972 }
00973 
00974 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00975 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key)
00976 {
00977   return this->implementation_.unbind (key);
00978 }
00979 
00980 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
00981 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key,
00982                                                                                             VALUE &value)
00983 {
00984   return this->implementation_.unbind (key,
00985                                        value);
00986 }
00987 
00988 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
00989 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const
00990 {
00991   return this->implementation_.current_size ();
00992 }
00993 
00994 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
00995 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const
00996 {
00997   return this->implementation_.total_size ();
00998 }
00999 
01000 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> void
01001 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const
01002 {
01003 #if defined (ACE_HAS_DUMP)
01004   this->implementation_.dump ();
01005 #endif /* ACE_HAS_DUMP */
01006 }
01007 
01008 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01009 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void)
01010 {
01011   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01012   ACE_NEW_RETURN (temp,
01013                   iterator_impl (this->implementation_.begin ()),
01014                   0);
01015   return temp;
01016 }
01017 
01018 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01019 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void)
01020 {
01021   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01022   ACE_NEW_RETURN (temp,
01023                   iterator_impl (this->implementation_.end ()),
01024                   0);
01025   return temp;
01026 }
01027 
01028 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01029 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void)
01030 {
01031   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01032   ACE_NEW_RETURN (temp,
01033                   reverse_iterator_impl (this->implementation_.rbegin ()),
01034                   0);
01035   return temp;
01036 }
01037 
01038 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01039 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void)
01040 {
01041   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01042   ACE_NEW_RETURN (temp,
01043                   reverse_iterator_impl (this->implementation_.rend ()),
01044                   0);
01045   return temp;
01046 }
01047 
01048 template <class T, class KEY, class VALUE>
01049 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void)
01050 {
01051 }
01052 
01053 template <class T, class KEY, class VALUE> ACE_Iterator_Impl<T> *
01054 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
01055 {
01056   ACE_Iterator_Impl<T> *temp = 0;
01057   ACE_NEW_RETURN (temp,
01058                   (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this),
01059                   0);
01060   return temp;
01061 }
01062 
01063 
01064 template <class T, class KEY, class VALUE> int
01065 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
01066 {
01067   const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local
01068     = dynamic_cast<const ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE> &> (rhs);
01069 
01070   return this->implementation_ == rhs_local.implementation_;
01071 }
01072 
01073 template <class T, class KEY, class VALUE> T
01074 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const
01075 {
01076   // The following syntax is necessary to work around certain broken compilers.
01077   // In particular, please do not prefix implementation_ with this->
01078   return T ((*implementation_).ext_id_,
01079             (*implementation_).int_id_);
01080 }
01081 
01082 template <class T, class KEY, class VALUE> void
01083 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
01084 {
01085   ++this->implementation_;
01086 }
01087 
01088 template <class T, class KEY, class VALUE> void
01089 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
01090 {
01091   --this->implementation_;
01092 }
01093 
01094 template <class T, class KEY, class VALUE>
01095 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void)
01096 {
01097 }
01098 
01099 template <class T, class KEY, class VALUE> ACE_Reverse_Iterator_Impl<T> *
01100 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
01101 {
01102   ACE_Reverse_Iterator_Impl<T> *temp = 0;
01103   ACE_NEW_RETURN (temp,
01104                   (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this),
01105                   0);
01106   return temp;
01107 }
01108 
01109 
01110 template <class T, class KEY, class VALUE> int
01111 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
01112 {
01113   const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local
01114     = dynamic_cast<const ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE> &> (rhs);
01115 
01116   return this->implementation_ == rhs_local.implementation_;
01117 }
01118 
01119 template <class T, class KEY, class VALUE> T
01120 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const
01121 {
01122   // The following syntax is necessary to work around certain broken compilers.
01123   // In particular, please do not prefix implementation_ with this->
01124   return T ((*implementation_).ext_id_,
01125             (*implementation_).int_id_);
01126 }
01127 
01128 template <class T, class KEY, class VALUE> void
01129 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
01130 {
01131   ++this->implementation_;
01132 }
01133 
01134 template <class T, class KEY, class VALUE> void
01135 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
01136 {
01137   --this->implementation_;
01138 }
01139 
01140 template <class KEY, class VALUE, class KEY_GENERATOR>
01141 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void)
01142 {
01143 }
01144 
01145 template <class KEY, class VALUE, class KEY_GENERATOR> int
01146 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length,
01147                                                           ACE_Allocator *alloc)
01148 {
01149   return this->implementation_.open (length,
01150                                      alloc);
01151 }
01152 
01153 template <class KEY, class VALUE, class KEY_GENERATOR> int
01154 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void)
01155 {
01156   return this->implementation_.close ();
01157 }
01158 
01159 template <class KEY, class VALUE, class KEY_GENERATOR> int
01160 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key,
01161                                                           const VALUE &value)
01162 {
01163   return this->implementation_.bind (key,
01164                                      value);
01165 }
01166 
01167 template <class KEY, class VALUE, class KEY_GENERATOR> int
01168 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
01169                                                                      KEY &key)
01170 {
01171   return this->implementation_.bind (key,
01172                                      value);
01173 }
01174 
01175 template <class KEY, class VALUE, class KEY_GENERATOR> int
01176 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key)
01177 {
01178   // Invoke the user specified key generation functor.
01179   return this->key_generator_ (key);
01180 }
01181 
01182 template <class KEY, class VALUE, class KEY_GENERATOR> int
01183 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value,
01184                                                                      KEY &key)
01185 {
01186   // Invoke the user specified key generation functor.
01187   int result = this->key_generator_ (key);
01188 
01189   if (result == 0)
01190     {
01191       // Try to add.
01192       result = this->implementation_.bind (key,
01193                                            value);
01194     }
01195 
01196   return result;
01197 }
01198 
01199 template <class KEY, class VALUE, class KEY_GENERATOR> int
01200 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value)
01201 {
01202   KEY key;
01203   return this->bind_create_key (value,
01204                                 key);
01205 }
01206 
01207 template <class KEY, class VALUE, class KEY_GENERATOR> int
01208 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key,
01209                                                                  KEY &original_key)
01210 {
01211   original_key = modified_key;
01212   return 0;
01213 }
01214 
01215 template <class KEY, class VALUE, class KEY_GENERATOR> int
01216 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01217                                                             const VALUE &value)
01218 {
01219   return this->implementation_.rebind (key,
01220                                        value);
01221 }
01222 
01223 template <class KEY, class VALUE, class KEY_GENERATOR> int
01224 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01225                                                             const VALUE &value,
01226                                                             VALUE &old_value)
01227 {
01228   return this->implementation_.rebind (key,
01229                                        value,
01230                                        old_value);
01231 }
01232 
01233 template <class KEY, class VALUE, class KEY_GENERATOR> int
01234 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01235                                                             const VALUE &value,
01236                                                             KEY &old_key,
01237                                                             VALUE &old_value)
01238 {
01239   return this->implementation_.rebind (key,
01240                                        value,
01241                                        old_key,
01242                                        old_value);
01243 }
01244 
01245 template <class KEY, class VALUE, class KEY_GENERATOR> int
01246 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key,
01247                                                              VALUE &value)
01248 {
01249   return this->implementation_.trybind (key,
01250                                         value);
01251 }
01252 
01253 template <class KEY, class VALUE, class KEY_GENERATOR> int
01254 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key,
01255                                                           VALUE &value)
01256 {
01257   return this->implementation_.find (key,
01258                                      value);
01259 }
01260 
01261 template <class KEY, class VALUE, class KEY_GENERATOR> int
01262 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key)
01263 {
01264   return this->implementation_.find (key);
01265 }
01266 
01267 template <class KEY, class VALUE, class KEY_GENERATOR> int
01268 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key)
01269 {
01270   return this->implementation_.unbind (key);
01271 }
01272 
01273 template <class KEY, class VALUE, class KEY_GENERATOR> int
01274 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key,
01275                                                             VALUE &value)
01276 {
01277   return this->implementation_.unbind (key,
01278                                        value);
01279 }
01280 
01281 template <class KEY, class VALUE, class KEY_GENERATOR> size_t
01282 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const
01283 {
01284   return this->implementation_.current_size ();
01285 }
01286 
01287 template <class KEY, class VALUE, class KEY_GENERATOR> size_t
01288 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const
01289 {
01290   return this->implementation_.total_size ();
01291 }
01292 
01293 template <class KEY, class VALUE, class KEY_GENERATOR> void
01294 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const
01295 {
01296 #if defined (ACE_HAS_DUMP)
01297   this->implementation_.dump ();
01298 #endif /* ACE_HAS_DUMP */
01299 }
01300 
01301 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01302 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void)
01303 {
01304   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01305   ACE_NEW_RETURN (temp,
01306                   iterator_impl (this->implementation_.begin ()),
01307                   0);
01308   return temp;
01309 }
01310 
01311 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01312 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void)
01313 {
01314   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01315   ACE_NEW_RETURN (temp,
01316                   iterator_impl (this->implementation_.end ()),
01317                   0);
01318   return temp;
01319 }
01320 
01321 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01322 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void)
01323 {
01324   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01325   ACE_NEW_RETURN (temp,
01326                   reverse_iterator_impl (this->implementation_.rbegin ()),
01327                   0);
01328   return temp;
01329 }
01330 
01331 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01332 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void)
01333 {
01334   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01335   ACE_NEW_RETURN (temp,
01336                   reverse_iterator_impl (this->implementation_.rend ()),
01337                   0);
01338   return temp;
01339 }
01340 
01341 ACE_END_VERSIONED_NAMESPACE_DECL
01342 
01343 #endif /* ACE_MAP_T_CPP */

Generated on Thu Nov 9 09:41:55 2006 for ACE by doxygen 1.3.6