## NAME

ACE_Hash_Map_Manager_Ex_Adapter - Defines a map implementation.

## SYNOPSIS

    #include <ace/Map_T.h>

    template<class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
    class ACE_Hash_Map_Manager_Ex_Adapter : public ACE_Map<KEY, VALUE>
    {
      public:
            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;

        ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc = 0);
        ACE_Hash_Map_Manager_Ex_Adapter (
            size_t size,
            ACE_Allocator *alloc = 0
            );
        virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void);
        virtual int open (
            size_t length = ACE_DEFAULT_MAP_SIZE,
            ACE_Allocator *alloc = 0
            );
        virtual int close (void);
        virtual int bind (const KEY &key, const VALUE &value);
        virtual int bind_modify_key (const VALUE &value, 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);
        virtual int find (const KEY &key);
        virtual int unbind (const KEY &key);
        virtual int unbind (const KEY &key, VALUE &value);
        virtual size_t current_size (void) const;
        virtual size_t total_size (void) const;
        virtual void dump (void) const;
        ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (
            void
            );
        KEY_GENERATOR &key_generator (void);
      protected:
            ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> implementation_;

        KEY_GENERATOR key_generator_;
        virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (
            void
            );
        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
            );
        virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (
            void
            );
      private:
        inline ACE_UNIMPLEMENTED_FUNC (
            void operator= (const ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR> &)
            );
    };

## DESCRIPTION

Implementation to be provided by `ACE_Hash_Map_Manager_Ex`.

## Traits.

        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;

## Initialization and termination methods.

    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
        );

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

    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);

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.

    virtual int bind_modify_key (const VALUE &value, KEY &key);

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.

    virtual int bind_create_key (const VALUE &value, KEY &key);

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.

    virtual int bind_create_key (const VALUE &value);

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.

    virtual int recover_key (const KEY &modified_key, KEY &original_key);

Recovers the original key potentially modified by the map during `bind_modify_key`.

    virtual int rebind (const KEY &key, const VALUE &value);

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.

    virtual int rebind (
        const KEY &key,
        const VALUE &value,
        VALUE &old_value
        );

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.

    virtual int rebind (
        const KEY &key,
        const VALUE &value,
        KEY &old_key,
        VALUE &old_value
        );

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.

    virtual int trybind (const KEY &key, VALUE &value);

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.

    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);

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

    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.

## STL styled iterator factory functions.

    virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (
        void
        );

    virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (
        void
        );

Return forward iterator.

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

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

Return reverse iterator.

## Disallow these operations.

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

## AUTHOR

Irfan Pyarali `irfan@cs.wustl.edu`

## LIBRARY

ace