ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR > Class Template Reference

Defines a map implementation. More...

#include <Map_T.h>

Inheritance diagram for ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >:
Inheritance graph
[legend]
Collaboration diagram for ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >:
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 Member Functions

 ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc=0)
 Initialize with the ACE_DEFAULT_MAP_SIZE.
 ACE_Hash_Map_Manager_Ex_Adapter (size_t size, ACE_Allocator *alloc=0)
virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void)
 Close down and release dynamically allocated resources.
virtual int open (size_t length=ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc=0)
 Initialize a Map with size length.
virtual int close (void)
 Close down a Map and release dynamically allocated resources.
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)
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.
virtual int find (const KEY &key)
 Is key in the map?
virtual int unbind (const KEY &key)
 Remove key from the map.
virtual int unbind (const KEY &key, VALUE &value)
virtual size_t current_size (void) const
 Return the current size of the map.
virtual size_t total_size (void) const
 Return the total size of the map.
virtual void dump (void) const
 Dump the state of an object.
ACE_Hash_Map_Manager_Ex< KEY,
VALUE, HASH_KEY, COMPARE_KEYS,
ACE_Null_Mutex > & 		impl (void)
 Accessor to implementation object.
KEY_GENERATOR & key_generator (void)
 Accessor to key generator.

Protected Member Functions

virtual ACE_Iterator_Impl
< ACE_Reference_Pair< const
KEY, VALUE > > * 		begin_impl (void)
 Return forward iterator.
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.
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.
KEY_GENERATOR key_generator_
 Functor class used for generating key.

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 1124 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< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::implementation

Definition at line 1134 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< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::iterator_impl

Definition at line 1130 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< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::reverse_iterator_impl

Definition at line 1132 of file Map_T.h.

Constructor & Destructor Documentation

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 ( ACE_Allocator *  alloc = 0  )  [inline]

Initialize with the ACE_DEFAULT_MAP_SIZE.

Definition at line 340 of file Map_T.inl.

00341   : implementation_ (alloc)
00342 {
00343 }

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 ( size_t  size,
ACE_Allocator *  alloc = 0 
) [inline]

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

Definition at line 346 of file Map_T.inl.

00348   : implementation_ (size,
00349                      alloc)
00350 {
00351 }

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 ( void   )  [inline, virtual]

Close down and release dynamically allocated resources.

Definition at line 848 of file Map_T.cpp.

00849 {
00850 }

Member Function Documentation

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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   )  [inline, protected, virtual]

Return forward iterator.

Implements ACE_Map< KEY, VALUE >.

Definition at line 1009 of file Map_T.cpp.

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 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind ( const KEY &  key,
const VALUE &  value 
) [inline, 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< KEY, VALUE >.

Definition at line 867 of file Map_T.cpp.

00869 {
00870   return this->implementation_.bind (key,
00871                                      value);
00872 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_create_key ( const VALUE &  value  )  [inline, 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< KEY, VALUE >.

Definition at line 907 of file Map_T.cpp.

00908 {
00909   KEY key;
00910   return this->bind_create_key (value,
00911                                 key);
00912 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_create_key ( const VALUE &  value,
KEY &  key 
) [inline, 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< KEY, VALUE >.

Definition at line 890 of file Map_T.cpp.

00892 {
00893   // Invoke the user specified key generation functor.
00894   int result = this->key_generator_ (key);
00895 
00896   if (result == 0)
00897     {
00898       // Try to add.
00899       result = this->implementation_.bind (key,
00900                                            value);
00901     }
00902 
00903   return result;
00904 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::bind_modify_key ( const VALUE &  value,
KEY &  key 
) [inline, 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< KEY, VALUE >.

Definition at line 875 of file Map_T.cpp.

00877 {
00878   return this->implementation_.bind (key,
00879                                      value);
00880 }

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

Close down a Map and release dynamically allocated resources.

Implements ACE_Map< KEY, VALUE >.

Definition at line 861 of file Map_T.cpp.

00862 {
00863   return this->implementation_.close ();
00864 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::create_key ( KEY &  key  )  [inline, 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< KEY, VALUE >.

Definition at line 883 of file Map_T.cpp.

00884 {
00885   // Invoke the user specified key generation functor.
00886   return this->key_generator_ (key);
00887 }

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

Return the current size of the map.

Implements ACE_Map< KEY, VALUE >.

Definition at line 989 of file Map_T.cpp.

00990 {
00991   return this->implementation_.current_size ();
00992 }

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 >::dump ( void   )  const [inline, virtual]

Dump the state of an object.

Implements ACE_Map< KEY, VALUE >.

Definition at line 1001 of file Map_T.cpp.

01002 {
01003 #if defined (ACE_HAS_DUMP)
01004   this->implementation_.dump ();
01005 #endif /* ACE_HAS_DUMP */
01006 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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   )  [inline, protected, virtual]

Implements ACE_Map< KEY, VALUE >.

Definition at line 1019 of file Map_T.cpp.

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 }

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

Is key in the map?

Implements ACE_Map< KEY, VALUE >.

Definition at line 969 of file Map_T.cpp.

00970 {
00971   return this->implementation_.find (key);
00972 }

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

Locate value associated with key.

Implements ACE_Map< KEY, VALUE >.

Definition at line 961 of file Map_T.cpp.

00963 {
00964   return this->implementation_.find (key,
00965                                      value);
00966 }

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< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::impl ( void   )  [inline]

Accessor to implementation object.

Definition at line 354 of file Map_T.inl.

00355 {
00356   return this->implementation_;
00357 }

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

Accessor to key generator.

Definition at line 360 of file Map_T.inl.

00361 {
00362   return this->key_generator_;
00363 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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 
) [inline, virtual]

Initialize a Map with size length.

Implements ACE_Map< KEY, VALUE >.

Definition at line 853 of file Map_T.cpp.

00855 {
00856   return this->implementation_.open (length,
00857                                      alloc);
00858 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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   )  [inline, protected, virtual]

Return reverse iterator.

Implements ACE_Map< KEY, VALUE >.

Definition at line 1029 of file Map_T.cpp.

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 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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 
) [inline, 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< KEY, VALUE >.

Definition at line 941 of file Map_T.cpp.

00945 {
00946   return this->implementation_.rebind (key,
00947                                        value,
00948                                        old_key,
00949                                        old_value);
00950 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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 
) [inline, 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< KEY, VALUE >.

Definition at line 931 of file Map_T.cpp.

00934 {
00935   return this->implementation_.rebind (key,
00936                                        value,
00937                                        old_value);
00938 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::rebind ( const KEY &  key,
const VALUE &  value 
) [inline, 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< KEY, VALUE >.

Definition at line 923 of file Map_T.cpp.

00925 {
00926   return this->implementation_.rebind (key,
00927                                        value);
00928 }

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

Recovers the original key potentially modified by the map during bind_modify_key().

Implements ACE_Map< KEY, VALUE >.

Definition at line 915 of file Map_T.cpp.

00917 {
00918   original_key = modified_key;
00919   return 0;
00920 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
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   )  [inline, protected, virtual]

Implements ACE_Map< KEY, VALUE >.

Definition at line 1039 of file Map_T.cpp.

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 }

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

Return the total size of the map.

Implements ACE_Map< KEY, VALUE >.

Definition at line 995 of file Map_T.cpp.

00996 {
00997   return this->implementation_.total_size ();
00998 }

template<class KEY , class VALUE , class HASH_KEY , class COMPARE_KEYS , class KEY_GENERATOR >
int ACE_Hash_Map_Manager_Ex_Adapter< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::trybind ( const KEY &  key,
VALUE &  value 
) [inline, 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< KEY, VALUE >.

Definition at line 953 of file Map_T.cpp.

00955 {
00956   return this->implementation_.trybind (key,
00957                                         value);
00958 }

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

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

Implements ACE_Map< KEY, VALUE >.

Definition at line 981 of file Map_T.cpp.

00983 {
00984   return this->implementation_.unbind (key,
00985                                        value);
00986 }

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

Remove key from the map.

Implements ACE_Map< KEY, VALUE >.

Definition at line 975 of file Map_T.cpp.

00976 {
00977   return this->implementation_.unbind (key);
00978 }

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< KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR >::implementation_ [protected]

All implementation details are forwarded to this class.

Definition at line 1288 of file Map_T.h.

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

Functor class used for generating key.

Definition at line 1291 of file Map_T.h.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri Nov 6 23:22:52 2009 for ACE by  doxygen 1.6.1