ACE/ace/Active_Map_Manager_T.h

   1 /* -*- C++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Active_Map_Manager_T.h
   6  *
   7  *  @author Irfan Pyarali
   8  */
   9 //=============================================================================
  10
  11
  12 #ifndef ACE_ACTIVE_MAP_MANAGER_T_H
  13 #define ACE_ACTIVE_MAP_MANAGER_T_H
  14 #include /**/ "ace/pre.h"
  15
  16 #include "ace/Map_Manager.h"
  17 #include "ace/Active_Map_Manager.h"
  18
  19 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  20 # pragma once
  21 #endif /* ACE_LACKS_PRAGMA_ONCE */
  22
  23 #include "ace/Null_Mutex.h"
  24
  25 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  26
  27 /**
  28  * @class ACE_Active_Map_Manager
  29  *
  30  * @brief Define a map abstraction that associates system generated
  31  * keys with user specified values.
  32  *
  33  * Since the key is system generated, searches are very fast and
  34  * take a constant amount of time.
  35  */
  36 template <class T>
  37 class ACE_Active_Map_Manager : public ACE_Map_Manager<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex>
  38 {
  39 public:
  40   // = Traits.
  41   typedef ACE_Active_Map_Manager_Key key_type;
  42   typedef T mapped_type;
  43
  44   typedef ACE_Map_Entry<ACE_Active_Map_Manager_Key, T> ENTRY;
  45   typedef ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> ITERATOR;
  46   typedef ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> REVERSE_ITERATOR;
  47
  48   typedef ENTRY entry;
  49   typedef ITERATOR iterator;
  50   typedef REVERSE_ITERATOR reverse_iterator;
  51
  52   /// Initialize a Active_Map_Manager with the ACE_DEFAULT_MAP_SIZE.
  53   ACE_Active_Map_Manager (ACE_Allocator *alloc = 0);
  54
  55   /// Initialize a Active_Map_Manager with @a size entries.
  56   ACE_Active_Map_Manager (size_t size,
  57                           ACE_Allocator *alloc = 0);
  58
  59   /// Close down a Active_Map_Manager and release dynamically
  60   /// allocated resources.
  61   ~ACE_Active_Map_Manager (void);
  62
  63   /// Initialize a Active_Map_Manager with size @a length.
  64   int open (size_t length = ACE_DEFAULT_MAP_SIZE,
  65             ACE_Allocator *alloc = 0);
  66
  67   /// Close down a Active_Map_Manager and release dynamically
  68   /// allocated resources.
  69   int close (void);
  70
  71   /// Add @a value to the map, and the corresponding key produced by the
  72   /// Active_Map_Manager is returned through @a key.
  73   int bind (const T &value,
  74             ACE_Active_Map_Manager_Key &key);
  75
  76   /// Add @a value to the map.  The user does not care about the
  77   /// corresponding key produced by the Active_Map_Manager.
  78   int bind (const T &value);
  79
  80   /**
  81    * Reserves a slot in the internal structure and returns the key and
  82    * a pointer to the value.  User should place their @a value into
  83    * @a internal_value.  This method is useful in reducing the number
  84    * of copies required in some cases.  Note that @a internal_value is
  85    * only a temporary pointer and will change when the map resizes.
  86    * Therefore, the user should use the pointer immediately and not
  87    * hold on to it.
  88    */
  89   int bind (ACE_Active_Map_Manager_Key &key,
  90             T *&internal_value);
  91
  92   /// Reassociate @a key with @a value. The function fails if @a key is
  93   /// not in the map.
  94   int rebind (const ACE_Active_Map_Manager_Key &key,
  95               const T &value);
  96
  97   /**
  98    * Reassociate @a key with @a value, storing the old value into the
  99    * "out" parameter @a old_value.  The function fails if @a key is not
 100    * in the map.
 101    */
 102   int rebind (const ACE_Active_Map_Manager_Key &key,
 103               const T &value,
 104               T &old_value);
 105
 106   /**
 107    * Reassociate @a key with @a value, storing the old key and value
 108    * into the "out" parameter @a old_key and @a old_value.  The function
 109    * fails if @a key is not in the map.
 110    */
 111   int rebind (const ACE_Active_Map_Manager_Key &key,
 112               const T &value,
 113               ACE_Active_Map_Manager_Key &old_key,
 114               T &old_value);
 115
 116   /// Locate @a value associated with @a key.
 117   int find (const ACE_Active_Map_Manager_Key &key,
 118             T &value) const;
 119
 120   /// Is @a key in the map?
 121   int find (const ACE_Active_Map_Manager_Key &key) const;
 122
 123   /**
 124    * Locate @a value associated with @a key.  The value is returned via
 125    * @a internal_value and hence a copy is saved.  Note that
 126    * @a internal_value is only a temporary pointer and will change when
 127    * the map resizes.  Therefore, the user should use the pointer
 128    * immediately and not hold on to it.
 129    */
 130   int find (const ACE_Active_Map_Manager_Key &key,
 131             T *&internal_value) const;
 132
 133   // Creates a key.  User should place their @a value into
 134   // <*internal_value>.  This method is useful in reducing the number
 135   // of copies required in some cases.
 136
 137   /// Remove @a key from the map.
 138   int unbind (const ACE_Active_Map_Manager_Key &key);
 139
 140   /// Remove @a key from the map, and return the @a value associated with
 141   /// @a key.
 142   int unbind (const ACE_Active_Map_Manager_Key &key,
 143               T &value);
 144
 145   /**
 146    * Locate @a value associated with @a key.  The value is returned via
 147    * @a internal_value and hence a copy is saved.  Note that
 148    * @a internal_value is only a temporary pointer and will change when
 149    * the map resizes or when this slot is reused.  Therefore, the user
 150    * should use the pointer immediately and not hold on to it.
 151    */
 152   int unbind (const ACE_Active_Map_Manager_Key &key,
 153               T *&internal_value);
 154
 155   /// Return the current size of the map.
 156   size_t current_size (void) const;
 157
 158   /// Return the total size of the map.
 159   size_t total_size (void) const;
 160
 161   /// Returns a key that cannot be found in the map.
 162   static const ACE_Active_Map_Manager_Key npos (void);
 163
 164   /// Dump the state of an object.
 165   void dump (void) const;
 166
 167   // = STL styled iterator factory functions.
 168
 169   /// Return forward iterator.
 170   ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> begin (void);
 171   ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> end (void);
 172
 173   /// Return reverse iterator.
 174   ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rbegin (void);
 175   ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rend (void);
 176
 177   /// Declare the dynamic allocation hooks.
 178   ACE_ALLOC_HOOK_DECLARE;
 179
 180 protected:
 181
 182   /// Private base class
 183   typedef ACE_Map_Manager<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> ACE_AMM_BASE;
 184
 185 private:
 186   // = Disallow these operations.
 187   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Active_Map_Manager<T> &))
 188   ACE_UNIMPLEMENTED_FUNC (ACE_Active_Map_Manager (const ACE_Active_Map_Manager<T> &))
 189 };
 190
 191 ACE_END_VERSIONED_NAMESPACE_DECL
 192
 193 #if defined (__ACE_INLINE__)
 194 #include "ace/Active_Map_Manager_T.inl"
 195 #endif /* __ACE_INLINE__ */
 196
 197 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
 198 #include "ace/Active_Map_Manager_T.cpp"
 199 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
 200
 201 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
 202 #pragma implementation ("Active_Map_Manager_T.cpp")
 203 #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
 204
 205 #include /**/ "ace/post.h"
 206 #endif /* ACE_ACTIVE_MAP_MANAGER_T_H */