ACE/ace/Cache_Map_Manager_T.cpp

   1 #ifndef ACE_CACHE_MAP_MANAGER_T_CPP
   2 #define ACE_CACHE_MAP_MANAGER_T_CPP
   3
   4 #include "ace/Cache_Map_Manager_T.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 #pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #include "ace/Log_Category.h"
  11 #include "ace/Malloc_Base.h"
  12
  13 #if !defined (__ACE_INLINE__)
  14 #include "ace/Cache_Map_Manager_T.inl"
  15 #endif /* __ACE_INLINE__ */
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 ACE_ALLOC_HOOK_DEFINE_Tc7(ACE_Cache_Map_Manager)
  20 ACE_ALLOC_HOOK_DEFINE_Tc5(ACE_Cache_Map_Iterator)
  21 ACE_ALLOC_HOOK_DEFINE_Tc5(ACE_Cache_Map_Reverse_Iterator)
  22
  23 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
  24 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::ACE_Cache_Map_Manager (CACHING_STRATEGY &caching_s,
  25                                                       size_t size,
  26                                                       ACE_Allocator *alloc)
  27   : caching_strategy_ (caching_s)
  28 {
  29   if (this->open (size, alloc) == -1)
  30     ACELIB_ERROR ((LM_ERROR,
  31                 ACE_TEXT ("%p\n"),
  32                 ACE_TEXT ("ACE_Cache_Map_Manager::ACE_Cache_Map_Manager")));
  33 }
  34
  35 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
  36 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::~ACE_Cache_Map_Manager ()
  37 {
  38   this->close ();
  39 }
  40
  41 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
  42 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::open (size_t length,
  43                                      ACE_Allocator *alloc)
  44 {
  45   return this->map_.open (length,
  46                           alloc);
  47 }
  48
  49 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
  50 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::close ()
  51 {
  52   return this->map_.close ();
  53 }
  54
  55 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
  56 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::bind (const KEY &key,
  57                                      const VALUE &value)
  58 {
  59   // Insert an entry which has the <key> and the <cache_value> which
  60   // is the combination of the <value> and the attributes of the
  61   // caching strategy.
  62   CACHE_VALUE cache_value (value,
  63                            this->caching_strategy_.attributes ());
  64
  65   int bind_result = this->map_.bind (key,
  66                                      cache_value);
  67
  68   if (bind_result != -1)
  69     {
  70       int result = this->caching_strategy_.notify_bind (bind_result,
  71                                                         cache_value.second);
  72
  73       if (result == -1)
  74         {
  75           this->map_.unbind (key);
  76
  77           // Unless the notification goes thru the bind operation is
  78           // not complete.
  79           bind_result = -1;
  80         }
  81
  82     }
  83
  84   return bind_result;
  85 }
  86
  87
  88 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
  89 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::rebind (const KEY &key,
  90                                        const VALUE &value)
  91 {
  92   CACHE_VALUE cache_value (value,
  93                            this->caching_strategy_.attributes ());
  94
  95   int rebind_result = this->map_.rebind (key,
  96                                          cache_value);
  97
  98   if (rebind_result != -1)
  99     {
 100       int result = this->caching_strategy_.notify_rebind (rebind_result,
 101                                                           cache_value.second ());
 102
 103       if (result == -1)
 104         {
 105           // Make sure the unbind operation is done only when the
 106           // notification fails after a bind which is denoted by
 107           // rebind_result = 0
 108           if (rebind_result == 0)
 109             this->map_.unbind (key);
 110
 111           // Unless the notification goes thru the rebind operation is
 112           // not complete.
 113           rebind_result = -1;
 114         }
 115
 116     }
 117
 118   return rebind_result;
 119 }
 120
 121
 122 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 123 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::rebind (const KEY &key,
 124                                        const VALUE &value,
 125                                        VALUE &old_value)
 126 {
 127   CACHE_VALUE cache_value (value,
 128                            this->caching_strategy_.attributes ());
 129
 130   CACHE_VALUE old_cache_value (old_value,
 131                                this->caching_strategy_.attributes ());
 132
 133   int rebind_result = this->map_.rebind (key,
 134                                          cache_value,
 135                                          old_cache_value);
 136
 137   if (rebind_result != -1)
 138     {
 139       int result = this->caching_strategy_.notify_rebind (rebind_result,
 140                                                           cache_value.second ());
 141
 142       if (result == -1)
 143         {
 144           // Make sure the unbind operation is done only when the
 145           // notification fails after a bind which is denoted by
 146           // rebind_result = 0
 147           if (rebind_result == 0)
 148             this->map_.unbind (key);
 149
 150           // Unless the notification goes thru the rebind operation is
 151           // not complete.
 152           rebind_result = -1;
 153         }
 154       else
 155         {
 156           old_value = old_cache_value.first ();
 157         }
 158
 159     }
 160
 161   return rebind_result;
 162 }
 163
 164 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 165 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::rebind (const KEY &key,
 166                                        const VALUE &value,
 167                                        KEY &old_key,
 168                                        VALUE &old_value)
 169 {
 170   CACHE_VALUE cache_value (value,
 171                            this->caching_strategy_.attributes ());
 172
 173   CACHE_VALUE old_cache_value (old_value,
 174                                this->caching_strategy_.attributes ());
 175
 176   int rebind_result = this->map_.rebind (key,
 177                                          cache_value,
 178                                          old_key,
 179                                          old_cache_value);
 180
 181   if (rebind_result != -1)
 182     {
 183       int result = this->caching_strategy_.notify_rebind (rebind_result,
 184                                                           cache_value.second ());
 185
 186       if (result == -1)
 187         {
 188           // Make sure the unbind operation is done only when the
 189           // notification fails after a bind which is denoted by
 190           // rebind_result = 0
 191           if (rebind_result == 0)
 192             this->map_.unbind (key);
 193
 194           // Unless the notification goes thru the rebind operation is
 195           // not complete.
 196           rebind_result = -1;
 197         }
 198       else
 199         {
 200           old_value = old_cache_value.first ();
 201         }
 202
 203     }
 204
 205   return rebind_result;
 206 }
 207
 208 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 209 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::trybind (const KEY &key,
 210                                         VALUE &value)
 211 {
 212   CACHE_VALUE cache_value (value,
 213                            this->caching_strategy_.attributes ());
 214
 215   int trybind_result = this->map_.trybind (key,
 216                                            cache_value);
 217
 218   if (trybind_result != -1)
 219     {
 220       int result = this->caching_strategy_.notify_trybind (trybind_result,
 221                                                            cache_value.second ());
 222
 223       if (result == -1)
 224         {
 225           // If the entry has got inserted into the map, it is removed
 226           // due to failure.
 227           if (trybind_result == 0)
 228             this->map_.unbind (key);
 229
 230           trybind_result = -1;
 231         }
 232       else
 233         {
 234           // If an attempt is made to bind an existing entry the value
 235           // is overwritten with the value from the map.
 236           if (trybind_result == 1)
 237             value = cache_value.first ();
 238         }
 239
 240     }
 241
 242   return trybind_result;
 243 }
 244
 245 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 246 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::find (const KEY &key,
 247                                      VALUE &value)
 248 {
 249   // Lookup the key and populate the <value>.
 250   CACHE_VALUE cache_value;
 251
 252   int find_result = this->map_.find (key,
 253                                      cache_value);
 254
 255   if (find_result != -1)
 256     {
 257       int result = this->caching_strategy_.notify_find (find_result,
 258                                                         cache_value.second);
 259
 260       // Unless the find and notification operations go thru, this
 261       // method is not successful.
 262       if (result == -1)
 263         find_result = -1;
 264       else
 265         {
 266           // Since the <cache_value> has now changed after the
 267           // notification, we need to bind to the map again.
 268           int rebind_result = this->map_.rebind (key,
 269                                                  cache_value);
 270           if (rebind_result == -1)
 271             find_result = -1;
 272           else
 273             value = cache_value.first;
 274         }
 275
 276     }
 277
 278   return find_result;
 279 }
 280
 281 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 282 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::find (const KEY &key)
 283 {
 284   // Lookup the key and populate the <value>.
 285   CACHE_VALUE cache_value;
 286
 287   int find_result = this->map_.find (key,
 288                                      cache_value);
 289
 290   if (find_result != -1)
 291     {
 292       int result = this->caching_strategy_.notify_find (find_result,
 293                                                         cache_value.second);
 294
 295       // Unless the find and notification operations go thru, this
 296       // method is not successful.
 297       if (result == -1)
 298         find_result = -1;
 299       else
 300         {
 301           // Since the <cache_value> has now changed after the
 302           // notification, we need to bind to the map again.
 303           int rebind_result = this->map_.rebind (key,
 304                                                  cache_value);
 305
 306           if (rebind_result == -1)
 307             find_result = -1;
 308         }
 309
 310     }
 311
 312   return find_result;
 313 }
 314
 315
 316 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 317 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::unbind (const KEY &key)
 318 {
 319   // Remove the entry from the cache.
 320   CACHE_VALUE cache_value;
 321
 322   int unbind_result = this->map_.unbind (key,
 323                                          cache_value);
 324
 325   if (unbind_result != -1)
 326     {
 327       int result = this->caching_strategy_.notify_unbind (unbind_result,
 328                                                           cache_value.second);
 329
 330       if (result == -1)
 331         unbind_result = -1;
 332     }
 333
 334   return unbind_result;
 335 }
 336
 337 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> int
 338 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::unbind (const KEY &key,
 339                                        VALUE &value)
 340 {
 341   // Remove the entry from the cache.
 342   CACHE_VALUE cache_value;
 343
 344   int unbind_result = this->map_.unbind (key,
 345                                          cache_value);
 346
 347   if (unbind_result != -1)
 348     {
 349       int result = this->caching_strategy_.notify_unbind (unbind_result,
 350                                                           cache_value.second ());
 351
 352       if (result == -1)
 353         unbind_result = -1;
 354       else
 355         value = cache_value.first ();
 356     }
 357
 358   return unbind_result;
 359 }
 360
 361 template <class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES> void
 362 ACE_Cache_Map_Manager<KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES>::dump () const
 363 {
 364 #if defined (ACE_HAS_DUMP)
 365   this->map_.dump ();
 366
 367   this->caching_strategy_.dump ();
 368 #endif /* ACE_HAS_DUMP */
 369 }
 370
 371 ACE_END_VERSIONED_NAMESPACE_DECL
 372
 373 #endif /* ACE_CACHE_MAP_MANAGER_T_CPP */