NAME
ACE_Map_Manager -
Define a map abstraction (useful for managing connections and
sessions).
SYNOPSIS
#include <ace/Map_Manager.h>
template<class EXT_ID, class INT_ID, class LOCK>
class ACE_Map_Manager
{
public:
friend class ACE_Map_Iterator<EXT_ID, INT_ID, LOCK>;
enum {DEFAULT_SIZE = ACE_DEFAULT_MAP_SIZE};
ACE_Map_Manager (ACE_Allocator *allocator = 0);
ACE_Map_Manager (size_t size, ACE_Allocator *allocator = 0);
int open (
size_t length = DEFAULT_SIZE,
ACE_Allocator *allocator = 0
);
int close (void);
~ACE_Map_Manager (void);
int trybind (const EXT_ID &ext_id, INT_ID &int_id);
int bind (const EXT_ID &ext_id, const INT_ID &int_id);
int rebind (
const EXT_ID &ext_id,
const INT_ID &int_id,
EXT_ID &old_ext_id,
INT_ID &old_int_id
);
int find (const EXT_ID &ext_id, INT_ID &int_id);
int find (const EXT_ID &ext_id);
int unbind (const EXT_ID &ext_id, INT_ID &int_id);
int unbind (const EXT_ID &ext_id);
int current_size (void);
int total_size (void);
void dump (void) const;
ACE_ALLOC_HOOK_DECLARE;
protected:
ACE_Map_Entry<EXT_ID, INT_ID> *search_structure_;
int bind_i (const EXT_ID &ext_id, const INT_ID &int_id);
int rebind_i (
const EXT_ID &ext_id,
const INT_ID &int_id,
EXT_ID &old_ext_id,
INT_ID &old_int_id
);
int find_i (const EXT_ID &ext_id, INT_ID &int_id);
int find_i (const EXT_ID &ext_id);
int unbind_i (const EXT_ID &ext_id, INT_ID &int_id);
int unbind_i (const EXT_ID &ext_id);
int trybind_i (const EXT_ID &ext_id, INT_ID &int_id);
int resize_i (size_t size);
int close_i (void);
ACE_Allocator *allocator_;
LOCK lock_;
private:
int shared_find (const EXT_ID &ext_id, int &first_free);
int shared_find (const EXT_ID &ext_id);
int shared_bind (
const EXT_ID &ext_id,
const INT_ID &int_id,
int first_free
);
int shared_unbind (const EXT_ID &ext_id);
size_t max_size_;
size_t cur_size_;
};
DESCRIPTION
This implementation of a map uses an array. It should
be enhanced to use a hash table...
This class uses an ACE_Allocator to allocate memory
The user can make this a persistant class by providing an
ACE_Allocator with a persistable memory pool
Initialization and termination methods.
ACE_Map_Manager (ACE_Allocator *allocator = 0);
Initialize a Map_Manager with the DEFAULT_SIZE.
ACE_Map_Manager (size_t size, ACE_Allocator *allocator = 0);
Initialize a Map_Manager with size entries.
int open (size_t length = DEFAULT_SIZE, ACE_Allocator *allocator = 0);
Initialize a Map_Manager with size length.
int close (void);
Close down a Map_Manager and release dynamically allocated
resources.
~ACE_Map_Manager (void);
Close down a Map_Manager and release dynamically allocated
resources.
int trybind (const EXT_ID &ext_id, INT_ID &int_id);
Associate ext_id with int_id if and only if ext_id is not
in the map. If ext_id is already in the map then the int_id
parameter is overwritten with the existing value in the map
Returns 0 if a new entry is bound successfully, returns 1 if an
attempt is made to bind an existing entry, and returns -1 if
failures occur.
int bind (const EXT_ID &ext_id, const INT_ID &int_id);
Associate ext_id with int_id. If ext_id is already in the
map then the Map_Entry is not changed. Returns 0 if a new
entry is bound successfully, returns 1 if an attempt is made to
bind an existing entry, and returns -1 if failures occur.
int rebind (
const EXT_ID &ext_id,
const INT_ID &int_id,
EXT_ID &old_ext_id,
INT_ID &old_int_id
);
Associate ext_id with int_id. If ext_id is not in the
map then behaves just like bind. Otherwise, store the old
values of ext_id and int_id into the "out" parameters and
rebind the new parameters. This is very useful if you need to
have an atomic way of updating Map_Entries and you also need
full control over memory allocation. Returns 0 if a new entry is
bound successfully, returns 1 if an existing entry was rebound,
and returns -1 if failures occur.
int find (const EXT_ID &ext_id, INT_ID &int_id);
Locate ext_id and pass out parameter via int_id. If found,
return 0, returns -1 if failure occurs.
int find (const EXT_ID &ext_id);
Returns 0 if the ext_id is in the mapping, otherwise -1.
int unbind (const EXT_ID &ext_id, INT_ID &int_id);
Break any association of ext_id. Returns the value of int_id in
case the caller needs to deallocate memory.
int unbind (const EXT_ID &ext_id);
Unbind (remove) the ext_id from the map. Don't return the int_id
to the caller (this is useful for collections where the int_ids
are *not* dynamically allocated...)
int current_size (void);
Return the current size of the map.
int total_size (void);
Return the total size of the map.
void dump (void) const;
Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
Declare the dynamic allocation hooks.
The following methods do the actual work and assume that
the locks are held by the private methods.
int bind_i (const EXT_ID &ext_id, const INT_ID &int_id);
Performs the binding of ext_id to int_id. Must be
called with locks held.
int rebind_i (
const EXT_ID &ext_id,
const INT_ID &int_id,
EXT_ID &old_ext_id,
INT_ID &old_int_id
);
Performs a rebinding of ext_it to int_id. Must be called
with locks held.
int find_i (const EXT_ID &ext_id, INT_ID &int_id);
Performs a find of int_id using ext_id as the key. Must be
called with locks held.
int find_i (const EXT_ID &ext_id);
Performs a find using ext_id as the key. Must be called with
locks held.
int unbind_i (const EXT_ID &ext_id, INT_ID &int_id);
Performs an unbind of int_id using ext_id as the key. Must
be called with locks held.
int unbind_i (const EXT_ID &ext_id);
Performs an unbind using ext_id as the key. Must be called
with locks held.
int trybind_i (const EXT_ID &ext_id, INT_ID &int_id);
Performs a conditional bind of int_id using ext_id as the
key. Must be called with locks held.
int resize_i (size_t size);
Resize the map. Must be called with locks held.
int close_i (void);
Close down a Map_Manager. Must be called with
locks held.
ACE_Allocator *allocator_;
Pointer to a memory allocator.
LOCK lock_;
Synchronization variable for the MT_SAFE ACE_Map_Manager.
AUTHOR
Doug Schmidt
LIBRARY
ace