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

ACE_Hash_Map_Manager_Ex_Adapter Class Template Reference

Defines a map implementation. More...

#include <Map_T.h>

Inheritance diagram for ACE_Hash_Map_Manager_Ex_Adapter:

Inheritance graph
[legend]
Collaboration diagram for ACE_Hash_Map_Manager_Ex_Adapter:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_Hash_Map_Manager_Ex_Iterator_Adapter<
ACE_Reference_Pair< const
KEY, VALUE >, KEY, VALUE,
HASH_KEY, COMPARE_KEYS > 		iterator_impl
typedef ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<
ACE_Reference_Pair< const
KEY, VALUE >, KEY, VALUE,
HASH_KEY, COMPARE_KEYS > 		reverse_iterator_impl
typedef ACE_Hash_Map_Manager_Ex<
KEY, VALUE, HASH_KEY, COMPARE_KEYS,
ACE_Null_Mutex > 		implementation

Public Methods

 ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc=0)
 Initialize with the <ACE_DEFAULT_MAP_SIZE>. More...

 ACE_Hash_Map_Manager_Ex_Adapter (size_t size, ACE_Allocator *alloc=0)
 Initialize with <size> entries. The <size> parameter is ignored by maps for which an initialize size does not make sense. More...

virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void)
 Close down and release dynamically allocated resources. More...

virtual int open (size_t length=ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc=0)
 Initialize a <Map> with size <length>. More...

virtual int close (void)
 Close down a <Map> and release dynamically allocated resources. More...

virtual int bind (const KEY &key, const VALUE &value)
virtual int bind_modify_key (const VALUE &value, KEY &key)
virtual int create_key (KEY &key)
virtual int bind_create_key (const VALUE &value, KEY &key)
virtual int bind_create_key (const VALUE &value)
virtual int recover_key (const KEY &modified_key, KEY &original_key)
 Recovers the original key potentially modified by the map during <bind_modify_key>. More...

virtual int rebind (const KEY &key, const VALUE &value)
virtual int rebind (const KEY &key, const VALUE &value, VALUE &old_value)
virtual int rebind (const KEY &key, const VALUE &value, KEY &old_key, VALUE &old_value)
virtual int trybind (const KEY &key, VALUE &value)
virtual int find (const KEY &key, VALUE &value)
 Locate <value> associated with <key>. More...

virtual int find (const KEY &key)
 Is <key> in the map? More...

virtual int unbind (const KEY &key)
 Remove <key> from the map. More...

virtual int unbind (const KEY &key, VALUE &value)
 Remove <key> from the map, and return the <value> associated with <key>. More...

virtual size_t current_size (void) const
 Return the current size of the map. More...

virtual size_t total_size (void) const
 Return the total size of the map. More...

virtual void dump (void) const
 Dump the state of an object. More...

ACE_Hash_Map_Manager_Ex< KEY,
VALUE, HASH_KEY, COMPARE_KEYS,
ACE_Null_Mutex > & 		impl (void)
 Accessor to implementation object. More...

KEY_GENERATOR & key_generator (void)
 Accessor to key generator. More...


Protected Methods

virtual ACE_Iterator_Impl<
ACE_Reference_Pair< const
KEY, VALUE > > * 		begin_impl (void)
 Return forward iterator. More...

virtual ACE_Iterator_Impl<
ACE_Reference_Pair< const
KEY, VALUE > > * 		end_impl (void)
virtual ACE_Reverse_Iterator_Impl<
ACE_Reference_Pair< const
KEY, VALUE > > * 		rbegin_impl (void)
 Return reverse iterator. More...

virtual ACE_Reverse_Iterator_Impl<
ACE_Reference_Pair< const
KEY, VALUE > > * 		rend_impl (void)

Protected Attributes

ACE_Hash_Map_Manager_Ex< KEY,
VALUE, HASH_KEY, COMPARE_KEYS,
ACE_Null_Mutex > 		implementation_
 All implementation details are forwarded to this class. More...

KEY_GENERATOR key_generator_
 Functor class used for generating key. More...


Private Methods

void operator= (const ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > &)
 ACE_Hash_Map_Manager_Ex_Adapter (const ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > &)

Detailed Description

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
class ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >

Defines a map implementation.

Implementation to be provided by <ACE_Hash_Map_Manager_Ex>.

Definition at line 1116 of file Map_T.h.

Member Typedef Documentation

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
typedef ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> ACE_Hash_Map_Manager_Ex_Adapter::implementation
 

Definition at line 1126 of file Map_T.h.

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
typedef ACE_Hash_Map_Manager_Ex_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE, HASH_KEY, COMPARE_KEYS> ACE_Hash_Map_Manager_Ex_Adapter::iterator_impl
 

Definition at line 1122 of file Map_T.h.

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
typedef ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE, HASH_KEY, COMPARE_KEYS> ACE_Hash_Map_Manager_Ex_Adapter::reverse_iterator_impl
 

Definition at line 1124 of file Map_T.h.

Constructor & Destructor Documentation

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::ACE_Hash_Map_Manager_Ex_Adapter (  ACE_Allocator *    alloc = 0 ) 
 

Initialize with the <ACE_DEFAULT_MAP_SIZE>.

Definition at line 1160 of file Map_T.i. 

01161   : implementation_ (alloc)
01162 {
01163 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::ACE_Hash_Map_Manager_Ex_Adapter (  size_t    size,
ACE_Allocator *    alloc = 0
) 
 

Initialize with <size> entries. The <size> parameter is ignored by maps for which an initialize size does not make sense.

Definition at line 1166 of file Map_T.i. 

01168   : implementation_ (size,
01169                      alloc)
01170 {
01171 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::~ACE_Hash_Map_Manager_Ex_Adapter (  void    )  [virtual]
 

Close down and release dynamically allocated resources.

Definition at line 1174 of file Map_T.i. 

01175 {
01176 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::ACE_Hash_Map_Manager_Ex_Adapter (  const ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > &    )  [private]
 

Member Function Documentation

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 > > * ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::begin_impl (  void    )  [protected, virtual]
 

Return forward iterator.

Implements ACE_Map.

Definition at line 1333 of file Map_T.i.

References ACE_NEW_RETURN. 

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 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind (  const KEY &    key,
const VALUE &    value
)  [virtual]
 

Add <key>/<value> pair to the map. If <key> is already in the map then no changes are made and 1 is returned. Returns 0 on a successful addition. This function fails for maps that do not allow user specified keys. <key> is an "in" parameter.

Implements ACE_Map.

Definition at line 1193 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::bind, and implementation_. 

01195 {
01196   return this->implementation_.bind (key,
01197                                      value);
01198 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_create_key (  const VALUE &    value )  [virtual]
 

Add <value> to the map. The user does not care about the corresponding key produced by the Map. For maps that do not naturally produce keys, the map adapters will use the <KEY_GENERATOR> class to produce a key. However, the users are responsible for not jeopardizing this key production scheme by using user specified keys with keys produced by the key generator.

Implements ACE_Map.

Definition at line 1233 of file Map_T.i.

References bind_create_key. 

01234 {
01235   KEY key;
01236   return this->bind_create_key (value,
01237                                 key);
01238 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_create_key (  const VALUE &    value,
KEY &    key
)  [virtual]
 

Add <value> to the map, and the corresponding key produced by the Map is returned through <key> which is an "out" parameter. For maps that do not naturally produce keys, the map adapters will use the <KEY_GENERATOR> class to produce a key. However, the users are responsible for not jeopardizing this key production scheme by using user specified keys with keys produced by the key generator.

Implements ACE_Map.

Definition at line 1216 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::bind, implementation_, and key_generator_.

Referenced by bind_create_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 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_modify_key (  const VALUE &    value,
KEY &    key
)  [virtual]
 

Add <key>/<value> pair to the map. <key> is an "inout" parameter and maybe modified/extended by the map to add additional information. To recover original key, call the <recover_key> method.

Implements ACE_Map.

Definition at line 1201 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::bind, and implementation_. 

01203 {
01204   return this->implementation_.bind (key,
01205                                      value);
01206 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::close (  void    )  [virtual]
 

Close down a <Map> and release dynamically allocated resources.

Implements ACE_Map.

Definition at line 1187 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::close, and implementation_. 

01188 {
01189   return this->implementation_.close ();
01190 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::create_key (  KEY &    key )  [virtual]
 

Produce a key and return it through <key> which is an "out" parameter. For maps that do not naturally produce keys, the map adapters will use the <KEY_GENERATOR> class to produce a key. However, the users are responsible for not jeopardizing this key production scheme by using user specified keys with keys produced by the key generator.

Implements ACE_Map.

Definition at line 1209 of file Map_T.i.

References key_generator_. 

01210 {
01211   // Invoke the user specified key generation functor.
01212   return this->key_generator_ (key);
01213 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE size_t ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::current_size (  void    )  const [virtual]
 

Return the current size of the map.

Implements ACE_Map.

Definition at line 1315 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::current_size, and implementation_. 

01316 {
01317   return this->implementation_.current_size ();
01318 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE void ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::dump (  void    )  const [virtual]
 

Dump the state of an object.

Implements ACE_Map.

Definition at line 1327 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::dump, and implementation_. 

01328 {
01329   this->implementation_.dump ();
01330 }

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 > > * ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::end_impl (  void    )  [protected, virtual]
 

Implements ACE_Map.

Definition at line 1343 of file Map_T.i.

References ACE_NEW_RETURN. 

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 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::find (  const KEY &    key )  [virtual]
 

Is <key> in the map?

Implements ACE_Map.

Definition at line 1295 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::find, and implementation_. 

01296 {
01297   return this->implementation_.find (key);
01298 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::find (  const KEY &    key,
VALUE &    value
)  [virtual]
 

Locate <value> associated with <key>.

Implements ACE_Map.

Definition at line 1287 of file Map_T.i.

References ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::find, and implementation_. 

01289 {
01290   return this->implementation_.find (key,
01291                                      value);
01292 }

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 > & ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::impl (  void    ) 
 

Accessor to implementation object.

Definition at line 1373 of file Map_T.i.

References implementation_. 

01374 {
01375   return this->implementation_;
01376 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE KEY_GENERATOR & ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::key_generator (  void    ) 
 

Accessor to key generator.

Definition at line 1379 of file Map_T.i.

References key_generator_. 

01380 {
01381   return this->key_generator_;
01382 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::open (  size_t    length = ACE_DEFAULT_MAP_SIZE,
ACE_Allocator *    alloc = 0
)  [virtual]
 

Initialize a <Map> with size <length>.

Implements ACE_Map.

Definition at line 1179 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::open. 

01181 {
01182   return this->implementation_.open (length,
01183                                      alloc);
01184 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
void ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::operator= (  const ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > &    )  [private]
 

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 > > * ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rbegin_impl (  void    )  [protected, virtual]
 

Return reverse iterator.

Implements ACE_Map.

Definition at line 1353 of file Map_T.i.

References ACE_NEW_RETURN. 

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 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rebind (  const KEY &    key,
const VALUE &    value,
KEY &    old_key,
VALUE &    old_value
)  [virtual]
 

Reassociate <key> with <value>, storing the old key and value into the "out" parameters <old_key> and <old_value>. The function fails if <key> is not in the map for maps that do not allow user specified keys. However, for maps that allow user specified keys, if the key is not in the map, a new <key>/<value> association is created.

Implements ACE_Map.

Definition at line 1267 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::rebind. 

01271 {
01272   return this->implementation_.rebind (key,
01273                                        value,
01274                                        old_key,
01275                                        old_value);
01276 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rebind (  const KEY &    key,
const VALUE &    value,
VALUE &    old_value
)  [virtual]
 

Reassociate <key> with <value>, storing the old value into the "out" parameter <old_value>. The function fails if <key> is not in the map for maps that do not allow user specified keys. However, for maps that allow user specified keys, if the key is not in the map, a new <key>/<value> association is created.

Implements ACE_Map.

Definition at line 1257 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::rebind. 

01260 {
01261   return this->implementation_.rebind (key,
01262                                        value,
01263                                        old_value);
01264 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rebind (  const KEY &    key,
const VALUE &    value
)  [virtual]
 

Reassociate <key> with <value>. The function fails if <key> is not in the map for maps that do not allow user specified keys. However, for maps that allow user specified keys, if the key is not in the map, a new <key>/<value> association is created.

Implements ACE_Map.

Definition at line 1249 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::rebind. 

01251 {
01252   return this->implementation_.rebind (key,
01253                                        value);
01254 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::recover_key (  const KEY &    modified_key,
KEY &    original_key
)  [virtual]
 

Recovers the original key potentially modified by the map during <bind_modify_key>.

Implements ACE_Map.

Definition at line 1241 of file Map_T.i. 

01243 {
01244   original_key = modified_key;
01245   return 0;
01246 }

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 > > * ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rend_impl (  void    )  [protected, virtual]
 

Implements ACE_Map.

Definition at line 1363 of file Map_T.i.

References ACE_NEW_RETURN. 

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 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE size_t ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::total_size (  void    )  const [virtual]
 

Return the total size of the map.

Implements ACE_Map.

Definition at line 1321 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::total_size. 

01322 {
01323   return this->implementation_.total_size ();
01324 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::trybind (  const KEY &    key,
VALUE &    value
)  [virtual]
 

Associate <key> with <value> if and only if <key> is not in the map. If <key> is already in the map, then the <value> parameter is overwritten with the existing value in the map. Returns 0 if a new <key>/<value> association is created. Returns 1 if an attempt is made to bind an existing entry. This function fails for maps that do not allow user specified keys.

Implements ACE_Map.

Definition at line 1279 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::trybind. 

01281 {
01282   return this->implementation_.trybind (key,
01283                                         value);
01284 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::unbind (  const KEY &    key,
VALUE &    value
)  [virtual]
 

Remove <key> from the map, and return the <value> associated with <key>.

Implements ACE_Map.

Definition at line 1307 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::unbind. 

01309 {
01310   return this->implementation_.unbind (key,
01311                                        value);
01312 }

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_INLINE int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::unbind (  const KEY &    key )  [virtual]
 

Remove <key> from the map.

Implements ACE_Map.

Definition at line 1301 of file Map_T.i.

References implementation_, and ACE_Hash_Map_Manager_Ex< KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex >::unbind. 

01302 {
01303   return this->implementation_.unbind (key);
01304 }

Member Data Documentation

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> ACE_Hash_Map_Manager_Ex_Adapter::implementation_ [protected]
 

All implementation details are forwarded to this class.

Definition at line 1280 of file Map_T.h.

Referenced by bind, bind_create_key, bind_modify_key, close, current_size, dump, find, impl, open, rebind, total_size, trybind, and unbind.

template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
KEY_GENERATOR ACE_Hash_Map_Manager_Ex_Adapter::key_generator_ [protected]
 

Functor class used for generating key.

Definition at line 1283 of file Map_T.h.

Referenced by bind_create_key, create_key, and key_generator.

The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:48:49 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002