dep/ACE_wrappers/ace/Cache_Map_Manager_T.cpp

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