00001
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
00011
00012 #if !defined (__ACE_INLINE__)
00013 #include "ace/Map_T.inl"
00014 #endif
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
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
00342
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
00388
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
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
00443
00444 result = this->key_adapter_.encode (key,
00445 active_key,
00446 internal_value->first ());
00447 if (result == 0)
00448 {
00449
00450 internal_value->second (value);
00451
00452 key = internal_value->first ();
00453 }
00454 else
00455 {
00456
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
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
00482 result = this->key_adapter_.encode (internal_value->first (),
00483 active_key,
00484 internal_value->first ());
00485 if (result == 0)
00486 {
00487
00488 internal_value->second (value);
00489
00490 key = internal_value->first ();
00491 }
00492 else
00493 {
00494
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
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
00513 result = this->key_adapter_.encode (internal_value->first (),
00514 active_key,
00515 internal_value->first ());
00516 if (result == 0)
00517 {
00518
00519 internal_value->second (value);
00520 }
00521 else
00522 {
00523
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
00536
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
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
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
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
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
00613 old_value = internal_value->second ();
00614
00615
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
00635 old_key = internal_value->first ();
00636 old_value = internal_value->second ();
00637
00638
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
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
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
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
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
00784
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
00830
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
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
00894 int result = this->key_generator_ (key);
00895
00896 if (result == 0)
00897 {
00898
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
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
01077
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
01123
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
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
01187 int result = this->key_generator_ (key);
01188
01189 if (result == 0)
01190 {
01191
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
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