Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

# ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > Class Template Reference

Defines a map implementation. More...

`#include <Map_T.h>`

Inheritance diagram for ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >:

[legend]
Collaboration diagram for ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >:

[legend]
List of all members.

## Public Types
typedef ACE_Pair< KEY, VALUE > | expanded_value
typedef ACE_Active_Map_Manager_Iterator_Adapter< ACE_Reference_Pair< const KEY, VALUE >, expanded_value > | iterator_impl
typedef ACE_Active_Map_Manager_Reverse_Iterator_Adapter< ACE_Reference_Pair< const KEY, VALUE >, expanded_value > | reverse_iterator_impl
typedef ACE_Active_Map_Manager< expanded_value > | implementation
## Public Member Functions
| ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc=0)
| Initialize with the <ace_default_map_size>.
| ACE_Active_Map_Manager_Adapter (size_t size, ACE_Allocator *alloc=0)
virtual | ~ACE_Active_Map_Manager_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_Active_Map_Manager< ACE_Pair< KEY, VALUE > > & | impl (void)
| Accessor to implementation object.
KEY_ADAPTER & | key_adapter (void)
| Accessor to key adapter.
## Protected Member Functions
virtual int | find (const KEY &key, expanded_value *&internal_value)
| Find helper.
virtual int | unbind (const KEY &key, expanded_value *&internal_value)
| Unbind helper.
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_Active_Map_Manager< ACE_Pair< KEY, VALUE > > | implementation_
| All implementation details are forwarded to this class.
KEY_ADAPTER | key_adapter_
| Adapts between the user key and the Active_Map_Manager_Key.
## Private Member Functions
void | operator= (const ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > &)
| ACE_Active_Map_Manager_Adapter (const ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > &)

## Detailed Description

### template<class KEY, class VALUE, class KEY_ADAPTER>
class ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >

Defines a map implementation.

Implementation to be provided by <ace_active_map_manager>.

## Member Typedef Documentation

template<class KEY, class VALUE, class KEY_ADAPTER>
typedef ACE_Pair<KEY, VALUE> ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::expanded_value

template<class KEY, class VALUE, class KEY_ADAPTER>
typedef ACE_Active_Map_Manager<expanded_value> ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::implementation

template<class KEY, class VALUE, class KEY_ADAPTER>
typedef ACE_Active_Map_Manager_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, expanded_value> ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::iterator_impl

template<class KEY, class VALUE, class KEY_ADAPTER>
typedef ACE_Active_Map_Manager_Reverse_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, expanded_value> ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::reverse_iterator_impl

## Constructor & Destructor Documentation

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_INLINE ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::ACE_Active_Map_Manager_Adapter | ( | ACE_Allocator * | alloc = `0` | ) |

| Initialize with the <ace_default_map_size>.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_INLINE ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::ACE_Active_Map_Manager_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.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::~ACE_Active_Map_Manager_Adapter | ( | void |  | ) | `[virtual]`

| Close down and release dynamically allocated resources.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::ACE_Active_Map_Manager_Adapter | ( | const ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > & |  | ) | `[private]`

## Member Function Documentation

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Iterator_Impl< ACE_Reference_Pair< const KEY, VALUE > > * ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::begin_impl | ( | void |  | ) | `[protected, virtual]`

| Return forward iterator. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::close | ( | void |  | ) | `[virtual]`

| Close down a <map> and release dynamically allocated resources. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
size_t ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::current_size | ( | void |  | ) | const`[virtual]`

| Return the current size of the map. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
void ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::dump | ( | void |  | ) | const`[virtual]`

| Dump the state of an object. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Iterator_Impl< ACE_Reference_Pair< const KEY, VALUE > > * ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::end_impl | ( | void |  | ) | `[protected, virtual]`

| Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::find | ( | const KEY & | key,
|  | expanded_value *& | internal_value
| ) | `[protected, virtual]`

| Find helper.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::find | ( | const KEY & | key | ) | `[virtual]`

| Is <key> in the map? Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::find | ( | const KEY & | key,
|  | VALUE & | value
| ) | `[virtual]`

| Locate <value> associated with <key>. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_INLINE ACE_Active_Map_Manager< ACE_Pair< KEY, VALUE > > & ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::impl | ( | void |  | ) |

| Accessor to implementation object.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_INLINE KEY_ADAPTER & ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::key_adapter | ( | void |  | ) |

| Accessor to key adapter.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::open | ( | size_t | length = `ACE_DEFAULT_MAP_SIZE`,
|  | ACE_Allocator * | alloc = `0`
| ) | `[virtual]`

| Initialize a <map> with size <length>. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
void ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::operator= | ( | const ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER > & |  | ) | `[private]`

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Reverse_Iterator_Impl< ACE_Reference_Pair< const KEY, VALUE > > * ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::rbegin_impl | ( | void |  | ) | `[protected, virtual]`

| Return reverse iterator. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Reverse_Iterator_Impl< ACE_Reference_Pair< const KEY, VALUE > > * ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::rend_impl | ( | void |  | ) | `[protected, virtual]`

| Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
size_t ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::total_size | ( | void |  | ) | const`[virtual]`

| Return the total size of the map. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::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< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::unbind | ( | const KEY & | key,
|  | expanded_value *& | internal_value
| ) | `[protected, virtual]`

| Unbind helper.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::unbind | ( | const KEY & | key,
|  | VALUE & | value
| ) | `[virtual]`

| Remove <key> from the map, and return the <value> associated with <key>. Implements ACE_Map< KEY, VALUE >.

template<class KEY, class VALUE, class KEY_ADAPTER>
int ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::unbind | ( | const KEY & | key | ) | `[virtual]`

| Remove <key> from the map. Implements ACE_Map< KEY, VALUE >.

## Member Data Documentation

template<class KEY, class VALUE, class KEY_ADAPTER>
ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::implementation_`[protected]`

| All implementation details are forwarded to this class.

template<class KEY, class VALUE, class KEY_ADAPTER>
KEY_ADAPTER ACE_Active_Map_Manager_Adapter< KEY, VALUE, KEY_ADAPTER >::key_adapter_`[protected]`

| Adapts between the user key and the Active_Map_Manager_Key.

The documentation for this class was generated from the following files:

- Map_T.h
- Map_T.cpp
- Map_T.inl