ACE/ace/Active_Map_Manager_T.inl

   1 // -*- C++ -*-
   2 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 template <class T> ACE_INLINE int
   5 ACE_Active_Map_Manager<T>::bind (ACE_Active_Map_Manager_Key &key,
   6                                  T *&internal_value)
   7 {
   8   ACE_UINT32 slot_index;
   9   int result = this->next_free (slot_index);
  10
  11   if (result == 0)
  12     {
  13       // Move from free list to occupied list
  14       this->move_from_free_list_to_occupied_list (slot_index);
  15
  16       // Reset the key.
  17       this->search_structure_[slot_index].ext_id_.increment_slot_generation_count ();
  18       this->search_structure_[slot_index].ext_id_.slot_index (slot_index);
  19
  20       // Copy the key for the user.
  21       key = this->search_structure_[slot_index].ext_id_;
  22
  23       // This is where the user should place the value.
  24       internal_value = &this->search_structure_[slot_index].int_id_;
  25
  26       // Update the current size.
  27       ++this->cur_size_;
  28     }
  29
  30   return result;
  31 }
  32
  33 template <class T> ACE_INLINE int
  34 ACE_Active_Map_Manager<T>::bind (const T &value,
  35                                  ACE_Active_Map_Manager_Key &key)
  36 {
  37   T *internal_value = 0;
  38   int result = this->bind (key,
  39                            internal_value);
  40
  41   if (result == 0)
  42     {
  43       // Store new value.
  44       *internal_value = value;
  45     }
  46
  47   return result;
  48 }
  49
  50 template <class T> ACE_INLINE int
  51 ACE_Active_Map_Manager<T>::bind (const T &value)
  52 {
  53   ACE_Active_Map_Manager_Key key;
  54   return this->bind (value, key);
  55 }
  56
  57 template <class T> ACE_INLINE int
  58 ACE_Active_Map_Manager<T>::find (const ACE_Active_Map_Manager_Key &key,
  59                                  T *&internal_value) const
  60 {
  61   ACE_UINT32 slot_index = key.slot_index ();
  62   ACE_UINT32 slot_generation = key.slot_generation ();
  63
  64   if (slot_index > this->total_size_ ||
  65 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
  66       this->search_structure_[slot_index].free_ ||
  67 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
  68       this->search_structure_[slot_index].ext_id_.slot_generation () != slot_generation ||
  69       this->search_structure_[slot_index].ext_id_.slot_index () ==
  70                  (ACE_UINT32)this->free_list_id ())
  71     {
  72       return -1;
  73     }
  74   else
  75     {
  76       // This is where the user value is.
  77       internal_value = &this->search_structure_[slot_index].int_id_;
  78     }
  79
  80   return 0;
  81 }
  82
  83 template <class T> ACE_INLINE int
  84 ACE_Active_Map_Manager<T>::find (const ACE_Active_Map_Manager_Key &key) const
  85 {
  86   T *internal_value = 0;
  87   return this->find (key,
  88                      internal_value);
  89 }
  90
  91 template <class T> ACE_INLINE int
  92 ACE_Active_Map_Manager<T>::find (const ACE_Active_Map_Manager_Key &key,
  93                                  T &value) const
  94 {
  95   T *internal_value = 0;
  96   int result = this->find (key,
  97                            internal_value);
  98
  99   if (result == 0)
 100     value = *internal_value;
 101
 102   return result;
 103 }
 104
 105 template <class T> ACE_INLINE int
 106 ACE_Active_Map_Manager<T>::rebind (const ACE_Active_Map_Manager_Key &key,
 107                                    const T &value)
 108 {
 109   int result = this->find (key);
 110
 111   if (result == 0)
 112     {
 113       // Store new value.
 114       this->search_structure_[key.slot_index ()].int_id_ = value;
 115     }
 116
 117   return result;
 118 }
 119
 120 template <class T> ACE_INLINE int
 121 ACE_Active_Map_Manager<T>::rebind (const ACE_Active_Map_Manager_Key &key,
 122                                    const T &value,
 123                                    T &old_value)
 124 {
 125   int result = this->find (key);
 126
 127   if (result == 0)
 128     {
 129       // Copy old value.
 130       old_value = this->search_structure_[key.slot_index ()].int_id_;
 131
 132       // Store new value.
 133       this->search_structure_[key.slot_index ()].int_id_ = value;
 134     }
 135
 136   return result;
 137 }
 138
 139 template <class T> ACE_INLINE int
 140 ACE_Active_Map_Manager<T>::rebind (const ACE_Active_Map_Manager_Key &key,
 141                                    const T &value,
 142                                    ACE_Active_Map_Manager_Key &old_key,
 143                                    T &old_value)
 144 {
 145   int result = this->find (key);
 146
 147   if (result == 0)
 148     {
 149       // Copy old key.
 150       old_key = this->search_structure_[key.slot_index ()].ext_id_;
 151
 152       // Copy old value.
 153       old_value = this->search_structure_[key.slot_index ()].int_id_;
 154
 155       // Store new value.
 156       this->search_structure_[key.slot_index ()].int_id_ = value;
 157     }
 158
 159   return result;
 160 }
 161
 162 template <class T> ACE_INLINE int
 163 ACE_Active_Map_Manager<T>::unbind (const ACE_Active_Map_Manager_Key &key,
 164                                    T *&internal_value)
 165 {
 166   int result = this->find (key,
 167                            internal_value);
 168
 169   if (result == 0)
 170     {
 171       ACE_UINT32 slot_index = key.slot_index ();
 172
 173 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 174
 175       //
 176       // In the case of lazy map managers, the movement of free slots
 177       // from the occupied list to the free list is delayed until we
 178       // run out of free slots in the free list.
 179       //
 180
 181       this->search_structure_[slot_index].free_ = 1;
 182
 183 #else
 184
 185       // Move from occupied list to free list.
 186       this->move_from_occupied_list_to_free_list (slot_index);
 187
 188 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 189
 190       // Reset the slot_index.  This will tell us that this entry is free.
 191       this->search_structure_[slot_index].ext_id_.slot_index (this->free_list_id ());
 192
 193       // Update the current size.
 194       --this->cur_size_;
 195     }
 196
 197   return result;
 198 }
 199
 200 template <class T> ACE_INLINE int
 201 ACE_Active_Map_Manager<T>::unbind (const ACE_Active_Map_Manager_Key &key,
 202                                    T &value)
 203 {
 204   T *internal_value;
 205   int result = this->unbind (key,
 206                              internal_value);
 207
 208   if (result == 0)
 209     {
 210       // Copy old value.
 211       value = *internal_value;
 212     }
 213
 214   return result;
 215 }
 216
 217 template <class T> ACE_INLINE int
 218 ACE_Active_Map_Manager<T>::unbind (const ACE_Active_Map_Manager_Key &key)
 219 {
 220   T *internal_value;
 221   return this->unbind (key,
 222                        internal_value);
 223 }
 224
 225 template <class T> ACE_INLINE
 226 ACE_Active_Map_Manager<T>::ACE_Active_Map_Manager (ACE_Allocator *alloc)
 227   : ACE_AMM_BASE (alloc)
 228 {
 229 }
 230
 231 template <class T> ACE_INLINE
 232 ACE_Active_Map_Manager<T>::ACE_Active_Map_Manager (size_t size,
 233                                                    ACE_Allocator *alloc)
 234   : ACE_AMM_BASE (size,
 235                   alloc)
 236 {
 237 }
 238
 239 template <class T> ACE_INLINE int
 240 ACE_Active_Map_Manager<T>::open (size_t length,
 241                                  ACE_Allocator *alloc)
 242 {
 243   return ACE_AMM_BASE::open (length, alloc);
 244 }
 245
 246 template <class T> ACE_INLINE int
 247 ACE_Active_Map_Manager<T>::close ()
 248 {
 249   return ACE_AMM_BASE::close ();
 250 }
 251
 252 template <class T> ACE_INLINE size_t
 253 ACE_Active_Map_Manager<T>::current_size () const
 254 {
 255   return ACE_AMM_BASE::current_size ();
 256 }
 257
 258 template <class T> ACE_INLINE size_t
 259 ACE_Active_Map_Manager<T>::total_size () const
 260 {
 261   return ACE_AMM_BASE::total_size ();
 262 }
 263
 264 /* static */
 265 template <class T> ACE_INLINE const ACE_Active_Map_Manager_Key
 266 ACE_Active_Map_Manager<T>::npos ()
 267 {
 268   return ACE_Active_Map_Manager_Key (~0, ~0);
 269 }
 270
 271 template <class T> ACE_INLINE void
 272 ACE_Active_Map_Manager<T>::dump () const
 273 {
 274 #if defined (ACE_HAS_DUMP)
 275   ACE_AMM_BASE::dump ();
 276 #endif /* ACE_HAS_DUMP */
 277 }
 278
 279 template <class T> ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex>
 280 ACE_Active_Map_Manager<T>::begin ()
 281 {
 282   return ACE_AMM_BASE::begin ();
 283 }
 284
 285 template <class T> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex>
 286 ACE_Active_Map_Manager<T>::end ()
 287 {
 288   return ACE_AMM_BASE::end ();
 289 }
 290
 291 template <class T> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex>
 292 ACE_Active_Map_Manager<T>::rbegin ()
 293 {
 294   return ACE_AMM_BASE::rbegin ();
 295 }
 296
 297 template <class T> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex>
 298 ACE_Active_Map_Manager<T>::rend ()
 299 {
 300   return ACE_AMM_BASE::rend ();
 301 }
 302
 303 ACE_END_VERSIONED_NAMESPACE_DECL