Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Map_T.i

Go to the documentation of this file.
00001 // $Id: Map_T.i,v 1.1.1.3 2003/02/21 18:36:32 chad Exp $
00002 
00003 template <class T> ACE_INLINE int
00004 ACE_Noop_Key_Generator<T>::operator() (T &)
00005 {
00006   return -1;
00007 }
00008 
00009 template <class T> ACE_INLINE
00010 ACE_Incremental_Key_Generator<T>::ACE_Incremental_Key_Generator (void)
00011   : t_ (0)
00012 {
00013 }
00014 
00015 template <class T> ACE_INLINE int
00016 ACE_Incremental_Key_Generator<T>::operator() (T &t)
00017 {
00018   t = ++this->t_;
00019   return 0;
00020 }
00021 
00022 template <class T> ACE_INLINE const T &
00023 ACE_Incremental_Key_Generator<T>::current_value (void) const
00024 {
00025   return this->t_;
00026 }
00027 
00028 template <class T> ACE_INLINE
00029 ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void)
00030 {
00031 }
00032 
00033 template <class T> ACE_INLINE
00034 ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void)
00035 {
00036 }
00037 
00038 template <class T> ACE_INLINE
00039 ACE_Iterator<T>::ACE_Iterator (ACE_Iterator_Impl<T> *impl)
00040   : implementation_ (impl)
00041 {
00042 }
00043 
00044 template <class T> ACE_INLINE
00045 ACE_Iterator<T>::ACE_Iterator (const ACE_Iterator<T> &rhs)
00046   : implementation_ (rhs.implementation_->clone ())
00047 {
00048 }
00049 
00050 template <class T> ACE_INLINE
00051 ACE_Iterator<T>::~ACE_Iterator (void)
00052 {
00053   delete this->implementation_;
00054 }
00055 
00056 template <class T> ACE_INLINE ACE_Iterator<T> &
00057 ACE_Iterator<T>::operator= (const ACE_Iterator<T> &rhs)
00058 {
00059   delete this->implementation_;
00060   this->implementation_ = rhs.implementation_->clone ();
00061   return *this;
00062 }
00063 
00064 template <class T> ACE_INLINE int
00065 ACE_Iterator<T>::operator== (const ACE_Iterator<T> &rhs) const
00066 {
00067   return this->implementation_->compare (*rhs.implementation_);
00068 }
00069 
00070 template <class T> ACE_INLINE int
00071 ACE_Iterator<T>::operator!= (const ACE_Iterator<T> &rhs) const
00072 {
00073   return !this->operator== (rhs);
00074 }
00075 
00076 template <class T> ACE_INLINE T
00077 ACE_Iterator<T>::operator* (void) const
00078 {
00079   return this->implementation_->dereference ();
00080 }
00081 
00082 template <class T> ACE_INLINE ACE_Iterator<T> &
00083 ACE_Iterator<T>::operator++ (void)
00084 {
00085   this->implementation_->plus_plus ();
00086   return *this;
00087 }
00088 
00089 template <class T> ACE_INLINE ACE_Iterator<T>
00090 ACE_Iterator<T>::operator++ (int)
00091 {
00092   ACE_Iterator<T> tmp = *this;
00093   this->implementation_->plus_plus ();
00094   return tmp;
00095 }
00096 
00097 template <class T> ACE_INLINE ACE_Iterator<T> &
00098 ACE_Iterator<T>::operator-- (void)
00099 {
00100   this->implementation_->minus_minus ();
00101   return *this;
00102 }
00103 
00104 template <class T> ACE_INLINE ACE_Iterator<T>
00105 ACE_Iterator<T>::operator-- (int)
00106 {
00107   ACE_Iterator<T> tmp = *this;
00108   this->implementation_->minus_minus ();
00109   return tmp;
00110 }
00111 
00112 template <class T> ACE_INLINE ACE_Iterator_Impl<T> &
00113 ACE_Iterator<T>::impl (void)
00114 {
00115   return *this->implementation_;
00116 }
00117 
00118 template <class T> ACE_INLINE
00119 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (ACE_Reverse_Iterator_Impl<T> *impl)
00120   : implementation_ (impl)
00121 {
00122 }
00123 
00124 template <class T> ACE_INLINE
00125 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rhs)
00126   : implementation_ (rhs.implementation_->clone ())
00127 {
00128 }
00129 
00130 template <class T> ACE_INLINE
00131 ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator (void)
00132 {
00133   delete this->implementation_;
00134 }
00135 
00136 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00137 ACE_Reverse_Iterator<T>::operator= (const ACE_Reverse_Iterator<T> &rhs)
00138 {
00139   delete this->implementation_;
00140   this->implementation_ = rhs.implementation_->clone ();
00141   return *this;
00142 }
00143 
00144 template <class T> ACE_INLINE int
00145 ACE_Reverse_Iterator<T>::operator== (const ACE_Reverse_Iterator<T> &rhs) const
00146 {
00147   return this->implementation_->compare (*rhs.implementation_);
00148 }
00149 
00150 template <class T> ACE_INLINE int
00151 ACE_Reverse_Iterator<T>::operator!= (const ACE_Reverse_Iterator<T> &rhs) const
00152 {
00153   return !this->operator== (rhs);
00154 }
00155 
00156 template <class T> ACE_INLINE T
00157 ACE_Reverse_Iterator<T>::operator* (void) const
00158 {
00159   return this->implementation_->dereference ();
00160 }
00161 
00162 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00163 ACE_Reverse_Iterator<T>::operator++ (void)
00164 {
00165   this->implementation_->plus_plus ();
00166   return *this;
00167 }
00168 
00169 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
00170 ACE_Reverse_Iterator<T>::operator++ (int)
00171 {
00172   ACE_Reverse_Iterator<T> tmp = *this;
00173   this->implementation_->plus_plus ();
00174   return tmp;
00175 }
00176 
00177 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00178 ACE_Reverse_Iterator<T>::operator-- (void)
00179 {
00180   this->implementation_->minus_minus ();
00181   return *this;
00182 }
00183 
00184 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
00185 ACE_Reverse_Iterator<T>::operator-- (int)
00186 {
00187   ACE_Reverse_Iterator<T> tmp = *this;
00188   this->implementation_->minus_minus ();
00189   return tmp;
00190 }
00191 
00192 template <class T> ACE_INLINE ACE_Reverse_Iterator_Impl<T> &
00193 ACE_Reverse_Iterator<T>::impl (void)
00194 {
00195   return *this->implementation_;
00196 }
00197 
00198 template <class KEY, class VALUE> ACE_INLINE
00199 ACE_Map<KEY, VALUE>::ACE_Map (void)
00200 {
00201 }
00202 
00203 template <class KEY, class VALUE> ACE_INLINE
00204 ACE_Map<KEY, VALUE>::~ACE_Map (void)
00205 {
00206 }
00207 
00208 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00209 ACE_Map<KEY, VALUE>::begin (void)
00210 {
00211   return iterator (this->begin_impl ());
00212 }
00213 
00214 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00215 ACE_Map<KEY, VALUE>::end (void)
00216 {
00217   return iterator (this->end_impl ());
00218 }
00219 
00220 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00221 ACE_Map<KEY, VALUE>::rbegin (void)
00222 {
00223   return reverse_iterator (this->rbegin_impl ());
00224 }
00225 
00226 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00227 ACE_Map<KEY, VALUE>::rend (void)
00228 {
00229   return reverse_iterator (this->rend_impl ());
00230 }
00231 
00232 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00233 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Iterator_Adapter (const IMPLEMENTATION &impl)
00234   : implementation_ (impl)
00235 {
00236 }
00237 
00238 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00239 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void)
00240 {
00241 }
00242 
00243 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE ACE_Iterator_Impl<T> *
00244 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
00245 {
00246   ACE_Iterator_Impl<T> *temp = 0;
00247   ACE_NEW_RETURN (temp,
00248                   (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
00249                   0);
00250   return temp;
00251 }
00252 
00253 
00254 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int
00255 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const
00256 {
00257   const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
00258     = ACE_dynamic_cast_3_ref (const ACE_Map_Impl_Iterator_Adapter, T, IMPLEMENTATION, ENTRY, rhs);
00259 
00260   return this->implementation_ == rhs_local.implementation_;
00261 }
00262 
00263 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE T
00264 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
00265 {
00266   ENTRY &entry = *this->implementation_;
00267   return T (entry.ext_id_,
00268             entry.int_id_);
00269 }
00270 
00271 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void
00272 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
00273 {
00274   ++this->implementation_;
00275 }
00276 
00277 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void
00278 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
00279 {
00280   --this->implementation_;
00281 }
00282 
00283 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
00284 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void)
00285 {
00286   return this->implementation_;
00287 }
00288 
00289 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00290 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Reverse_Iterator_Adapter (const IMPLEMENTATION &impl)
00291   : implementation_ (impl)
00292 {
00293 }
00294 
00295 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00296 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void)
00297 {
00298 }
00299 
00300 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<T> *
00301 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
00302 {
00303   ACE_Reverse_Iterator_Impl<T> *temp = 0;
00304   ACE_NEW_RETURN (temp,
00305                   (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
00306                   0);
00307   return temp;
00308 }
00309 
00310 
00311 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int
00312 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
00313 {
00314   const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
00315     = ACE_dynamic_cast_3_ref (const ACE_Map_Impl_Reverse_Iterator_Adapter, T, IMPLEMENTATION, ENTRY, rhs);
00316 
00317   return this->implementation_ == rhs_local.implementation_;
00318 }
00319 
00320 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE T
00321 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
00322 {
00323   ENTRY &entry = *this->implementation_;
00324   return T (entry.ext_id_,
00325             entry.int_id_);
00326 }
00327 
00328 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void
00329 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
00330 {
00331   ++this->implementation_;
00332 }
00333 
00334 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void
00335 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
00336 {
00337   --this->implementation_;
00338 }
00339 
00340 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
00341 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void)
00342 {
00343   return this->implementation_;
00344 }
00345 
00346 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
00347 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (ACE_Allocator *alloc)
00348   : implementation_ (alloc)
00349 {
00350 }
00351 
00352 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
00353 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (size_t size,
00354                                                                                            ACE_Allocator *alloc)
00355   : implementation_ (size,
00356                      alloc)
00357 {
00358 }
00359 
00360 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
00361 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void)
00362 {
00363 }
00364 
00365 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00366 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length,
00367                                                                                    ACE_Allocator *alloc)
00368 {
00369   return this->implementation_.open (length,
00370                                      alloc);
00371 }
00372 
00373 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00374 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void)
00375 {
00376   return this->implementation_.close ();
00377 }
00378 
00379 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00380 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key,
00381                                                                                    const VALUE &value)
00382 {
00383   return this->implementation_.bind (key,
00384                                      value);
00385 }
00386 
00387 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00388 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value,
00389                                                                                               KEY &key)
00390 {
00391   return this->implementation_.bind_modify_key (value,
00392                                                 key);
00393 }
00394 
00395 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00396 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key)
00397 {
00398   return this->implementation_.create_key (key);
00399 }
00400 
00401 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00402 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value,
00403                                                                                               KEY &key)
00404 {
00405   return this->implementation_.bind_create_key (value,
00406                                                 key);
00407 }
00408 
00409 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00410 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value)
00411 {
00412   return this->implementation_.bind_create_key (value);
00413 }
00414 
00415 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00416 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key,
00417                                                                                           KEY &original_key)
00418 {
00419   return this->implementation_.recover_key (modified_key,
00420                                             original_key);
00421 }
00422 
00423 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00424 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00425                                                                                      const VALUE &value)
00426 {
00427   return this->implementation_.rebind (key,
00428                                        value);
00429 }
00430 
00431 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00432 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00433                                                                                      const VALUE &value,
00434                                                                                      VALUE &old_value)
00435 {
00436   return this->implementation_.rebind (key,
00437                                        value,
00438                                        old_value);
00439 }
00440 
00441 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00442 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
00443                                                                                      const VALUE &value,
00444                                                                                      KEY &old_key,
00445                                                                                      VALUE &old_value)
00446 {
00447   return this->implementation_.rebind (key,
00448                                        value,
00449                                        old_key,
00450                                        old_value);
00451 }
00452 
00453 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00454 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key,
00455                                                                                       VALUE &value)
00456 {
00457   return this->implementation_.trybind (key,
00458                                         value);
00459 }
00460 
00461 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00462 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key,
00463                                                                                    VALUE &value)
00464 {
00465   return this->implementation_.find (key,
00466                                      value);
00467 }
00468 
00469 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00470 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key)
00471 {
00472   return this->implementation_.find (key);
00473 }
00474 
00475 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00476 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key)
00477 {
00478   return this->implementation_.unbind (key);
00479 }
00480 
00481 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
00482 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key,
00483                                                                                      VALUE &value)
00484 {
00485   return this->implementation_.unbind (key,
00486                                        value);
00487 }
00488 
00489 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t
00490 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const
00491 {
00492   return this->implementation_.current_size ();
00493 }
00494 
00495 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t
00496 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const
00497 {
00498   return this->implementation_.total_size ();
00499 }
00500 
00501 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE void
00502 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const
00503 {
00504   this->implementation_.dump ();
00505 }
00506 
00507 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00508 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void)
00509 {
00510   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00511   ACE_NEW_RETURN (temp,
00512                   iterator_impl (this->implementation_.begin ()),
00513                   0);
00514   return temp;
00515 }
00516 
00517 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00518 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void)
00519 {
00520   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00521   ACE_NEW_RETURN (temp,
00522                   iterator_impl (this->implementation_.end ()),
00523                   0);
00524   return temp;
00525 }
00526 
00527 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00528 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void)
00529 {
00530   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00531   ACE_NEW_RETURN (temp,
00532                   reverse_iterator_impl (this->implementation_.rbegin ()),
00533                   0);
00534   return temp;
00535 }
00536 
00537 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00538 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void)
00539 {
00540   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00541   ACE_NEW_RETURN (temp,
00542                   reverse_iterator_impl (this->implementation_.rend ()),
00543                   0);
00544   return temp;
00545 }
00546 
00547 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE IMPLEMENTATION &
00548 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl (void)
00549 {
00550   return this->implementation_;
00551 }
00552 
00553 template <class T, class VALUE> ACE_INLINE
00554 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl)
00555   : implementation_ (impl)
00556 {
00557 }
00558 
00559 template <class T, class VALUE> ACE_INLINE
00560 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void)
00561 {
00562 }
00563 
00564 template <class T, class VALUE> ACE_INLINE ACE_Iterator_Impl<T> *
00565 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const
00566 {
00567   ACE_Iterator_Impl<T> *temp = 0;
00568   ACE_NEW_RETURN (temp,
00569                   (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this),
00570                   0);
00571   return temp;
00572 }
00573 
00574 
00575 template <class T, class VALUE> ACE_INLINE int
00576 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
00577 {
00578   const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local
00579     = ACE_dynamic_cast_2_ref (const ACE_Active_Map_Manager_Iterator_Adapter, T, VALUE, rhs);
00580 
00581   return this->implementation_ == rhs_local.implementation_;
00582 }
00583 
00584 template <class T, class VALUE> ACE_INLINE T
00585 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const
00586 {
00587   // The following syntax is necessary to work around certain broken compilers.
00588   // In particular, please do not prefix implementation_ with this->
00589   return T ((*implementation_).int_id_.first (),
00590             (*implementation_).int_id_.second ());
00591 }
00592 
00593 template <class T, class VALUE> ACE_INLINE void
00594 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void)
00595 {
00596   ++this->implementation_;
00597 }
00598 
00599 template <class T, class VALUE> ACE_INLINE void
00600 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void)
00601 {
00602   --this->implementation_;
00603 }
00604 
00605 template <class T, class VALUE> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
00606 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl (void)
00607 {
00608   return this->implementation_;
00609 }
00610 
00611 template <class T, class VALUE> ACE_INLINE
00612 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl)
00613   : implementation_ (impl)
00614 {
00615 }
00616 
00617 template <class T, class VALUE> ACE_INLINE
00618 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void)
00619 {
00620 }
00621 
00622 template <class T, class VALUE> ACE_INLINE ACE_Reverse_Iterator_Impl<T> *
00623 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const
00624 {
00625   ACE_Reverse_Iterator_Impl<T> *temp = 0;
00626   ACE_NEW_RETURN (temp,
00627                   (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this),
00628                   0);
00629   return temp;
00630 }
00631 
00632 
00633 template <class T, class VALUE> ACE_INLINE int
00634 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
00635 {
00636   const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local
00637     = ACE_dynamic_cast_2_ref (const ACE_Active_Map_Manager_Reverse_Iterator_Adapter, T, VALUE, rhs);
00638 
00639   return this->implementation_ == rhs_local.implementation_;
00640 }
00641 
00642 template <class T, class VALUE> ACE_INLINE T
00643 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const
00644 {
00645   // The following syntax is necessary to work around certain broken compilers.
00646   // In particular, please do not prefix implementation_ with this->
00647   return T ((*implementation_).int_id_.first (),
00648             (*implementation_).int_id_.second ());
00649 }
00650 
00651 template <class T, class VALUE> ACE_INLINE void
00652 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void)
00653 {
00654   ++this->implementation_;
00655 }
00656 
00657 template <class T, class VALUE> ACE_INLINE void
00658 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void)
00659 {
00660   --this->implementation_;
00661 }
00662 
00663 template <class T, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
00664 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl (void)
00665 {
00666   return this->implementation_;
00667 }
00668 
00669 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
00670 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc)
00671   : implementation_ (alloc)
00672 {
00673 }
00674 
00675 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
00676 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (size_t size,
00677                                                                                          ACE_Allocator *alloc)
00678   : implementation_ (size,
00679                      alloc)
00680 {
00681 }
00682 
00683 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
00684 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void)
00685 {
00686 }
00687 
00688 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00689 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length,
00690                                                                ACE_Allocator *alloc)
00691 {
00692   return this->implementation_.open (length,
00693                                      alloc);
00694 }
00695 
00696 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00697 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void)
00698 {
00699   return this->implementation_.close ();
00700 }
00701 
00702 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00703 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &,
00704                                                                const VALUE &)
00705 {
00706   ACE_NOTSUP_RETURN (-1);
00707 }
00708 
00709 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00710 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value,
00711                                                                           KEY &key)
00712 {
00713   // Reserve a slot and create an active key.
00714   expanded_value *internal_value = 0;
00715   ACE_Active_Map_Manager_Key active_key;
00716   int result = this->implementation_.bind (active_key,
00717                                            internal_value);
00718   if (result == 0)
00719     {
00720       // Encode the active key and the existing user key into key part
00721       // of <expanded_value>.
00722       result = this->key_adapter_.encode (key,
00723                                           active_key,
00724                                           internal_value->first ());
00725       if (result == 0)
00726         {
00727           // Copy user value into <expanded_value>.
00728           internal_value->second (value);
00729           // Copy new, modified key back to the user key.
00730           key = internal_value->first ();
00731         }
00732       else
00733         {
00734           // In case of errors, unbind from map.
00735           this->implementation_.unbind (active_key);
00736         }
00737     }
00738 
00739   return result;
00740 }
00741 
00742 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00743 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &)
00744 {
00745   ACE_NOTSUP_RETURN (-1);
00746 }
00747 
00748 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00749 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value,
00750                                                                           KEY &key)
00751 {
00752   // Reserve a slot and create an active key.
00753   expanded_value *internal_value = 0;
00754   ACE_Active_Map_Manager_Key active_key;
00755   int result = this->implementation_.bind (active_key,
00756                                            internal_value);
00757   if (result == 0)
00758     {
00759       // Encode the active key into key part of <expanded_value>.
00760       result = this->key_adapter_.encode (internal_value->first (),
00761                                           active_key,
00762                                           internal_value->first ());
00763       if (result == 0)
00764         {
00765           // Copy user value into <expanded_value>.
00766           internal_value->second (value);
00767           // Copy new, modified key to the user key.
00768           key = internal_value->first ();
00769         }
00770       else
00771         {
00772           // In case of errors, unbind from map.
00773           this->implementation_.unbind (active_key);
00774         }
00775     }
00776 
00777   return result;
00778 }
00779 
00780 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00781 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value)
00782 {
00783   // Reserve a slot and create an active key.
00784   expanded_value *internal_value = 0;
00785   ACE_Active_Map_Manager_Key active_key;
00786   int result = this->implementation_.bind (active_key,
00787                                            internal_value);
00788   if (result == 0)
00789     {
00790       // Encode the active key into key part of <expanded_value>.
00791       result = this->key_adapter_.encode (internal_value->first (),
00792                                           active_key,
00793                                           internal_value->first ());
00794       if (result == 0)
00795         {
00796           // Copy user value into <expanded_value>.
00797           internal_value->second (value);
00798         }
00799       else
00800         {
00801           // In case of errors, unbind from map.
00802           this->implementation_.unbind (active_key);
00803         }
00804     }
00805 
00806   return result;
00807 }
00808 
00809 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00810 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key,
00811                                                                       KEY &original_key)
00812 {
00813   // Ask the <key_adapter_> to help out with recovering the original
00814   // user key, since it was the one that encode it in the first place.
00815   return this->key_adapter_.decode (modified_key,
00816                                     original_key);
00817 }
00818 
00819 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00820 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
00821                                                                expanded_value *&internal_value)
00822 {
00823   // Ask the <key_adapter_> to recover the active key.
00824   ACE_Active_Map_Manager_Key active_key;
00825   int result = this->key_adapter_.decode (key,
00826                                           active_key);
00827   if (result == 0)
00828     {
00829       // Find recovered active key in map.
00830       result = this->implementation_.find (active_key,
00831                                            internal_value);
00832     }
00833 
00834   return result;
00835 }
00836 
00837 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00838 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
00839                                                                VALUE &value)
00840 {
00841   expanded_value *internal_value = 0;
00842   int result = this->find (key,
00843                            internal_value);
00844 
00845   if (result == 0)
00846     {
00847       // Copy value.
00848       value = internal_value->second ();
00849     }
00850 
00851   return result;
00852 }
00853 
00854 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00855 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key)
00856 {
00857   expanded_value *internal_value = 0;
00858   return this->find (key,
00859                      internal_value);
00860 }
00861 
00862 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00863 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00864                                                                  const VALUE &value)
00865 {
00866   expanded_value *internal_value = 0;
00867   int result = this->find (key,
00868                            internal_value);
00869 
00870   if (result == 0)
00871     {
00872       // Reset value.
00873       internal_value->second (value);
00874     }
00875 
00876   return result;
00877 }
00878 
00879 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00880 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00881                                                                  const VALUE &value,
00882                                                                  VALUE &old_value)
00883 {
00884   expanded_value *internal_value = 0;
00885   int result = this->find (key,
00886                            internal_value);
00887 
00888   if (result == 0)
00889     {
00890       // Copy old value.
00891       old_value = internal_value->second ();
00892 
00893       // Reset to new value.
00894       internal_value->second (value);
00895     }
00896 
00897   return result;
00898 }
00899 
00900 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00901 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
00902                                                                  const VALUE &value,
00903                                                                  KEY &old_key,
00904                                                                  VALUE &old_value)
00905 {
00906   expanded_value *internal_value = 0;
00907   int result = this->find (key,
00908                            internal_value);
00909 
00910   if (result == 0)
00911     {
00912       // Copy old key and value.
00913       old_key = internal_value->first ();
00914       old_value = internal_value->second ();
00915 
00916       // Reset to new value.
00917       internal_value->second (value);
00918     }
00919 
00920   return result;
00921 }
00922 
00923 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00924 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &,
00925                                                                   VALUE &)
00926 {
00927   ACE_NOTSUP_RETURN (-1);
00928 }
00929 
00930 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00931 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
00932                                                                  expanded_value *&internal_value)
00933 {
00934   // Ask the <key_adapter_> to recover the active key.
00935   ACE_Active_Map_Manager_Key active_key;
00936   int result = this->key_adapter_.decode (key,
00937                                           active_key);
00938   if (result == 0)
00939     {
00940       // Unbind recovered active key from map.
00941       result = this->implementation_.unbind (active_key,
00942                                              internal_value);
00943     }
00944 
00945   return result;
00946 }
00947 
00948 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00949 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key)
00950 {
00951   expanded_value *internal_value = 0;
00952   return this->unbind (key,
00953                        internal_value);
00954 }
00955 
00956 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
00957 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
00958                                                                  VALUE &value)
00959 {
00960   expanded_value *internal_value = 0;
00961   int result = this->unbind (key,
00962                              internal_value);
00963 
00964   if (result == 0)
00965     {
00966       // Copy value.
00967       value = internal_value->second ();
00968     }
00969 
00970   return result;
00971 }
00972 
00973 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t
00974 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const
00975 {
00976   return this->implementation_.current_size ();
00977 }
00978 
00979 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t
00980 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const
00981 {
00982   return this->implementation_.total_size ();
00983 }
00984 
00985 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE void
00986 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const
00987 {
00988   this->implementation_.dump ();
00989 }
00990 
00991 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
00992 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void)
00993 {
00994   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
00995   ACE_NEW_RETURN (temp,
00996                   iterator_impl (this->implementation_.begin ()),
00997                   0);
00998   return temp;
00999 }
01000 
01001 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01002 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void)
01003 {
01004   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01005   ACE_NEW_RETURN (temp,
01006                   iterator_impl (this->implementation_.end ()),
01007                   0);
01008   return temp;
01009 }
01010 
01011 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01012 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void)
01013 {
01014   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01015   ACE_NEW_RETURN (temp,
01016                   reverse_iterator_impl (this->implementation_.rbegin ()),
01017                   0);
01018   return temp;
01019 }
01020 
01021 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01022 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void)
01023 {
01024   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01025   ACE_NEW_RETURN (temp,
01026                   reverse_iterator_impl (this->implementation_.rend ()),
01027                   0);
01028   return temp;
01029 }
01030 
01031 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > &
01032 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl (void)
01033 {
01034   return this->implementation_;
01035 }
01036 
01037 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE KEY_ADAPTER &
01038 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::key_adapter (void)
01039 {
01040   return this->key_adapter_;
01041 }
01042 
01043 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
01044 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::ACE_Hash_Map_Manager_Ex_Iterator_Adapter (const ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl)
01045   : implementation_ (impl)
01046 {
01047 }
01048 
01049 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
01050 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void)
01051 {
01052 }
01053 
01054 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Iterator_Impl<T> *
01055 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
01056 {
01057   ACE_Iterator_Impl<T> *temp = 0;
01058   ACE_NEW_RETURN (temp,
01059                   (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
01060                   0);
01061   return temp;
01062 }
01063 
01064 
01065 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE int
01066 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const
01067 {
01068   const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
01069     = ACE_dynamic_cast_5_ref (const ACE_Hash_Map_Manager_Ex_Iterator_Adapter, T, KEY, VALUE, HASH_KEY, COMPARE_KEYS, rhs);
01070 
01071   return this->implementation_ == rhs_local.implementation_;
01072 }
01073 
01074 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE T
01075 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
01076 {
01077   // The following syntax is necessary to work around certain broken compilers.
01078   // In particular, please do not prefix implementation_ with this->
01079   return T ((*implementation_).ext_id_,
01080             (*implementation_).int_id_);
01081 }
01082 
01083 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void
01084 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
01085 {
01086   ++this->implementation_;
01087 }
01088 
01089 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void
01090 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
01091 {
01092   --this->implementation_;
01093 }
01094 
01095 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
01096 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void)
01097 {
01098   return this->implementation_;
01099 }
01100 
01101 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
01102 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (const ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl)
01103   : implementation_ (impl)
01104 {
01105 }
01106 
01107 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
01108 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void)
01109 {
01110 }
01111 
01112 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Reverse_Iterator_Impl<T> *
01113 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
01114 {
01115   ACE_Reverse_Iterator_Impl<T> *temp = 0;
01116   ACE_NEW_RETURN (temp,
01117                   (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
01118                   0);
01119   return temp;
01120 }
01121 
01122 
01123 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE int
01124 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
01125 {
01126   const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
01127     = ACE_dynamic_cast_5_ref (const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter, T, KEY, VALUE, HASH_KEY, COMPARE_KEYS, rhs);
01128 
01129   return this->implementation_ == rhs_local.implementation_;
01130 }
01131 
01132 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE T
01133 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
01134 {
01135   // The following syntax is necessary to work around certain broken compilers.
01136   // In particular, please do not prefix implementation_ with this->
01137   return T ((*implementation_).ext_id_,
01138             (*implementation_).int_id_);
01139 }
01140 
01141 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void
01142 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
01143 {
01144   ++this->implementation_;
01145 }
01146 
01147 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void
01148 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
01149 {
01150   --this->implementation_;
01151 }
01152 
01153 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
01154 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void)
01155 {
01156   return this->implementation_;
01157 }
01158 
01159 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
01160 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc)
01161   : implementation_ (alloc)
01162 {
01163 }
01164 
01165 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
01166 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (size_t size,
01167                                                                                                                      ACE_Allocator *alloc)
01168   : implementation_ (size,
01169                      alloc)
01170 {
01171 }
01172 
01173 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
01174 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void)
01175 {
01176 }
01177 
01178 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01179 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length,
01180                                                                                           ACE_Allocator *alloc)
01181 {
01182   return this->implementation_.open (length,
01183                                      alloc);
01184 }
01185 
01186 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01187 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void)
01188 {
01189   return this->implementation_.close ();
01190 }
01191 
01192 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01193 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key,
01194                                                                                           const VALUE &value)
01195 {
01196   return this->implementation_.bind (key,
01197                                      value);
01198 }
01199 
01200 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01201 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
01202                                                                                                      KEY &key)
01203 {
01204   return this->implementation_.bind (key,
01205                                      value);
01206 }
01207 
01208 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01209 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key)
01210 {
01211   // Invoke the user specified key generation functor.
01212   return this->key_generator_ (key);
01213 }
01214 
01215 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01216 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value,
01217                                                                                                      KEY &key)
01218 {
01219   // Invoke the user specified key generation functor.
01220   int result = this->key_generator_ (key);
01221 
01222   if (result == 0)
01223     {
01224       // Try to add.
01225       result = this->implementation_.bind (key,
01226                                            value);
01227     }
01228 
01229   return result;
01230 }
01231 
01232 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01233 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value)
01234 {
01235   KEY key;
01236   return this->bind_create_key (value,
01237                                 key);
01238 }
01239 
01240 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01241 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key,
01242                                                                                                  KEY &original_key)
01243 {
01244   original_key = modified_key;
01245   return 0;
01246 }
01247 
01248 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01249 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
01250                                                                                             const VALUE &value)
01251 {
01252   return this->implementation_.rebind (key,
01253                                        value);
01254 }
01255 
01256 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01257 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
01258                                                                                             const VALUE &value,
01259                                                                                             VALUE &old_value)
01260 {
01261   return this->implementation_.rebind (key,
01262                                        value,
01263                                        old_value);
01264 }
01265 
01266 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01267 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
01268                                                                                             const VALUE &value,
01269                                                                                             KEY &old_key,
01270                                                                                             VALUE &old_value)
01271 {
01272   return this->implementation_.rebind (key,
01273                                        value,
01274                                        old_key,
01275                                        old_value);
01276 }
01277 
01278 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01279 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key,
01280                                                                                              VALUE &value)
01281 {
01282   return this->implementation_.trybind (key,
01283                                         value);
01284 }
01285 
01286 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01287 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key,
01288                                                                                           VALUE &value)
01289 {
01290   return this->implementation_.find (key,
01291                                      value);
01292 }
01293 
01294 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01295 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key)
01296 {
01297   return this->implementation_.find (key);
01298 }
01299 
01300 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01301 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key)
01302 {
01303   return this->implementation_.unbind (key);
01304 }
01305 
01306 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
01307 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key,
01308                                                                                             VALUE &value)
01309 {
01310   return this->implementation_.unbind (key,
01311                                        value);
01312 }
01313 
01314 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t
01315 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const
01316 {
01317   return this->implementation_.current_size ();
01318 }
01319 
01320 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t
01321 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const
01322 {
01323   return this->implementation_.total_size ();
01324 }
01325 
01326 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE void
01327 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const
01328 {
01329   this->implementation_.dump ();
01330 }
01331 
01332 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01333 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void)
01334 {
01335   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01336   ACE_NEW_RETURN (temp,
01337                   iterator_impl (this->implementation_.begin ()),
01338                   0);
01339   return temp;
01340 }
01341 
01342 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01343 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void)
01344 {
01345   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01346   ACE_NEW_RETURN (temp,
01347                   iterator_impl (this->implementation_.end ()),
01348                   0);
01349   return temp;
01350 }
01351 
01352 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01353 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void)
01354 {
01355   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01356   ACE_NEW_RETURN (temp,
01357                   reverse_iterator_impl (this->implementation_.rbegin ()),
01358                   0);
01359   return temp;
01360 }
01361 
01362 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01363 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void)
01364 {
01365   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01366   ACE_NEW_RETURN (temp,
01367                   reverse_iterator_impl (this->implementation_.rend ()),
01368                   0);
01369   return temp;
01370 }
01371 
01372 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
01373 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl (void)
01374 {
01375   return this->implementation_;
01376 }
01377 
01378 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
01379 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::key_generator (void)
01380 {
01381   return this->key_generator_;
01382 }
01383 
01384 template <class T, class KEY, class VALUE> ACE_INLINE
01385 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl)
01386   : implementation_ (impl)
01387 {
01388 }
01389 
01390 template <class T, class KEY, class VALUE> ACE_INLINE
01391 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void)
01392 {
01393 }
01394 
01395 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Iterator_Impl<T> *
01396 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
01397 {
01398   ACE_Iterator_Impl<T> *temp = 0;
01399   ACE_NEW_RETURN (temp,
01400                   (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this),
01401                   0);
01402   return temp;
01403 }
01404 
01405 
01406 template <class T, class KEY, class VALUE> ACE_INLINE int
01407 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
01408 {
01409   const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local
01410     = ACE_dynamic_cast_3_ref (const ACE_Map_Manager_Iterator_Adapter, T, KEY, VALUE, rhs);
01411 
01412   return this->implementation_ == rhs_local.implementation_;
01413 }
01414 
01415 template <class T, class KEY, class VALUE> ACE_INLINE T
01416 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const
01417 {
01418   // The following syntax is necessary to work around certain broken compilers.
01419   // In particular, please do not prefix implementation_ with this->
01420   return T ((*implementation_).ext_id_,
01421             (*implementation_).int_id_);
01422 }
01423 
01424 template <class T, class KEY, class VALUE> ACE_INLINE void
01425 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
01426 {
01427   ++this->implementation_;
01428 }
01429 
01430 template <class T, class KEY, class VALUE> ACE_INLINE void
01431 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
01432 {
01433   --this->implementation_;
01434 }
01435 
01436 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &
01437 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl (void)
01438 {
01439   return this->implementation_;
01440 }
01441 
01442 template <class T, class KEY, class VALUE> ACE_INLINE
01443 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl)
01444   : implementation_ (impl)
01445 {
01446 }
01447 
01448 template <class T, class KEY, class VALUE> ACE_INLINE
01449 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void)
01450 {
01451 }
01452 
01453 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator_Impl<T> *
01454 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
01455 {
01456   ACE_Reverse_Iterator_Impl<T> *temp = 0;
01457   ACE_NEW_RETURN (temp,
01458                   (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this),
01459                   0);
01460   return temp;
01461 }
01462 
01463 
01464 template <class T, class KEY, class VALUE> ACE_INLINE int
01465 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
01466 {
01467   const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local
01468     = ACE_dynamic_cast_3_ref (const ACE_Map_Manager_Reverse_Iterator_Adapter, T, KEY, VALUE, rhs);
01469 
01470   return this->implementation_ == rhs_local.implementation_;
01471 }
01472 
01473 template <class T, class KEY, class VALUE> ACE_INLINE T
01474 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const
01475 {
01476   // The following syntax is necessary to work around certain broken compilers.
01477   // In particular, please do not prefix implementation_ with this->
01478   return T ((*implementation_).ext_id_,
01479             (*implementation_).int_id_);
01480 }
01481 
01482 template <class T, class KEY, class VALUE> ACE_INLINE void
01483 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
01484 {
01485   ++this->implementation_;
01486 }
01487 
01488 template <class T, class KEY, class VALUE> ACE_INLINE void
01489 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
01490 {
01491   --this->implementation_;
01492 }
01493 
01494 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &
01495 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl (void)
01496 {
01497   return this->implementation_;
01498 }
01499 
01500 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
01501 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (ACE_Allocator *alloc)
01502   : implementation_ (alloc)
01503 {
01504 }
01505 
01506 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
01507 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (size_t size,
01508                                                                              ACE_Allocator *alloc)
01509   : implementation_ (size,
01510                      alloc)
01511 {
01512 }
01513 
01514 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
01515 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void)
01516 {
01517 }
01518 
01519 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01520 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length,
01521                                                           ACE_Allocator *alloc)
01522 {
01523   return this->implementation_.open (length,
01524                                      alloc);
01525 }
01526 
01527 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01528 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void)
01529 {
01530   return this->implementation_.close ();
01531 }
01532 
01533 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01534 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key,
01535                                                           const VALUE &value)
01536 {
01537   return this->implementation_.bind (key,
01538                                      value);
01539 }
01540 
01541 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01542 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
01543                                                                      KEY &key)
01544 {
01545   return this->implementation_.bind (key,
01546                                      value);
01547 }
01548 
01549 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01550 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key)
01551 {
01552   // Invoke the user specified key generation functor.
01553   return this->key_generator_ (key);
01554 }
01555 
01556 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01557 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value,
01558                                                                      KEY &key)
01559 {
01560   // Invoke the user specified key generation functor.
01561   int result = this->key_generator_ (key);
01562 
01563   if (result == 0)
01564     {
01565       // Try to add.
01566       result = this->implementation_.bind (key,
01567                                            value);
01568     }
01569 
01570   return result;
01571 }
01572 
01573 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01574 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value)
01575 {
01576   KEY key;
01577   return this->bind_create_key (value,
01578                                 key);
01579 }
01580 
01581 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01582 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key,
01583                                                                  KEY &original_key)
01584 {
01585   original_key = modified_key;
01586   return 0;
01587 }
01588 
01589 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01590 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01591                                                             const VALUE &value)
01592 {
01593   return this->implementation_.rebind (key,
01594                                        value);
01595 }
01596 
01597 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01598 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01599                                                             const VALUE &value,
01600                                                             VALUE &old_value)
01601 {
01602   return this->implementation_.rebind (key,
01603                                        value,
01604                                        old_value);
01605 }
01606 
01607 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01608 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
01609                                                             const VALUE &value,
01610                                                             KEY &old_key,
01611                                                             VALUE &old_value)
01612 {
01613   return this->implementation_.rebind (key,
01614                                        value,
01615                                        old_key,
01616                                        old_value);
01617 }
01618 
01619 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01620 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key,
01621                                                              VALUE &value)
01622 {
01623   return this->implementation_.trybind (key,
01624                                         value);
01625 }
01626 
01627 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01628 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key,
01629                                                           VALUE &value)
01630 {
01631   return this->implementation_.find (key,
01632                                      value);
01633 }
01634 
01635 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01636 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key)
01637 {
01638   return this->implementation_.find (key);
01639 }
01640 
01641 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01642 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key)
01643 {
01644   return this->implementation_.unbind (key);
01645 }
01646 
01647 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
01648 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key,
01649                                                             VALUE &value)
01650 {
01651   return this->implementation_.unbind (key,
01652                                        value);
01653 }
01654 
01655 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t
01656 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const
01657 {
01658   return this->implementation_.current_size ();
01659 }
01660 
01661 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t
01662 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const
01663 {
01664   return this->implementation_.total_size ();
01665 }
01666 
01667 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE void
01668 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const
01669 {
01670   this->implementation_.dump ();
01671 }
01672 
01673 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01674 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void)
01675 {
01676   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01677   ACE_NEW_RETURN (temp,
01678                   iterator_impl (this->implementation_.begin ()),
01679                   0);
01680   return temp;
01681 }
01682 
01683 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01684 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void)
01685 {
01686   ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01687   ACE_NEW_RETURN (temp,
01688                   iterator_impl (this->implementation_.end ()),
01689                   0);
01690   return temp;
01691 }
01692 
01693 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01694 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void)
01695 {
01696   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01697   ACE_NEW_RETURN (temp,
01698                   reverse_iterator_impl (this->implementation_.rbegin ()),
01699                   0);
01700   return temp;
01701 }
01702 
01703 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
01704 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void)
01705 {
01706   ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
01707   ACE_NEW_RETURN (temp,
01708                   reverse_iterator_impl (this->implementation_.rend ()),
01709                   0);
01710   return temp;
01711 }
01712 
01713 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &
01714 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl (void)
01715 {
01716   return this->implementation_;
01717 }
01718 
01719 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
01720 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::key_generator (void)
01721 {
01722   return this->key_generator_;
01723 }

Generated on Mon Jun 16 11:20:16 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002