dep/ACE_wrappers/ace/Hash_Cache_Map_Manager_T.cpp

   1 // $Id: Hash_Cache_Map_Manager_T.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #ifndef ACE_HASH_CACHE_MAP_MANAGER_T_CPP
   4 #define ACE_HASH_CACHE_MAP_MANAGER_T_CPP
   5
   6 #include "ace/Hash_Cache_Map_Manager_T.h"
   7
   8 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   9 #pragma once
  10 #endif /* ACE_LACKS_PRAGMA_ONCE */
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/Hash_Cache_Map_Manager_T.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_ALLOC_HOOK_DEFINE(ACE_Hash_Cache_Map_Manager)
  19
  20 #define ACE_T1 class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class CACHING_STRATEGY, class ATTRIBUTES
  21 #define ACE_T2 KEY, VALUE,  HASH_KEY, COMPARE_KEYS, CACHING_STRATEGY, ATTRIBUTES
  22
  23 template <ACE_T1>
  24 ACE_Hash_Cache_Map_Manager<ACE_T2>::ACE_Hash_Cache_Map_Manager (CACHING_STRATEGY &caching_s,
  25                                                              size_t size,
  26                                                              ACE_Allocator *alloc)
  27   : ACE_HCMM_BASE (caching_s,
  28                    size,
  29                    alloc)
  30 {
  31 }
  32
  33 template <ACE_T1>
  34 ACE_Hash_Cache_Map_Manager<ACE_T2>::~ACE_Hash_Cache_Map_Manager (void)
  35 {
  36 }
  37
  38 template <ACE_T1> int
  39 ACE_Hash_Cache_Map_Manager<ACE_T2>::bind (const KEY &key,
  40                                           const VALUE &value,
  41                                           CACHE_ENTRY *&entry)
  42 {
  43   // Insert a entry which has the <key> and the <cache_value> which is
  44   // the combination of the <value> and the attributes of the caching
  45   // strategy.
  46   CACHE_VALUE cache_value (value,
  47                            this->caching_strategy_.attributes ());
  48
  49   int bind_result = this->map_.bind (key,
  50                                      cache_value,
  51                                      entry);
  52
  53   if (bind_result != -1)
  54     {
  55
  56       int result = this->caching_strategy_.notify_bind (bind_result,
  57                                                         cache_value.second ());
  58
  59       if (result == -1)
  60         {
  61
  62           this->map_.unbind (key);
  63
  64           // Unless the notification goes thru the bind operation is
  65           // not complete.
  66           bind_result = -1;
  67
  68         }
  69     }
  70
  71   return bind_result;
  72 }
  73
  74 template <ACE_T1> int
  75 ACE_Hash_Cache_Map_Manager<ACE_T2>::rebind (const KEY &key,
  76                                          const VALUE &value,
  77                                          CACHE_ENTRY *&entry)
  78 {
  79   CACHE_VALUE cache_value (value,
  80                            this->caching_strategy_.attributes ());
  81
  82   int rebind_result = this->map_.rebind (key,
  83                                          cache_value,
  84                                          entry);
  85
  86   if (rebind_result != -1)
  87     {
  88
  89       int result = this->caching_strategy_.notify_rebind (rebind_result,
  90                                                           cache_value.second ());
  91
  92       if (result == -1)
  93         {
  94
  95           // Make sure the unbind operation is done only when the
  96           // notification fails after a bind which is denoted by
  97           // rebind_result = 0
  98           if (rebind_result == 0)
  99             this->map_.unbind (key);
 100
 101           // Unless the notification goes thru the rebind operation is
 102           // not complete.
 103           rebind_result = -1;
 104
 105         }
 106
 107     }
 108
 109   return rebind_result;
 110 }
 111
 112 template <ACE_T1> int
 113 ACE_Hash_Cache_Map_Manager<ACE_T2>::trybind (const KEY &key,
 114                                           VALUE &value,
 115                                           CACHE_ENTRY *&entry)
 116 {
 117   CACHE_VALUE cache_value (value,
 118                            this->caching_strategy_.attributes ());
 119
 120   int trybind_result = this->map_.trybind (key,
 121                                            cache_value,
 122                                            entry);
 123
 124   if (trybind_result != -1)
 125     {
 126       int result = this->caching_strategy_.notify_trybind (trybind_result,
 127                                                            cache_value.second ());
 128
 129       if (result == -1)
 130         {
 131
 132           // If the entry has got inserted into the map, it is removed
 133           // due to failure.
 134           if (trybind_result == 0)
 135             this->map_.unbind (key);
 136
 137           trybind_result = -1;
 138
 139         }
 140       else
 141         {
 142
 143           // If an attempt is made to bind an existing entry the value
 144           // is overwritten with the value from the map.
 145           if (trybind_result == 1)
 146             value = cache_value.first ();
 147
 148         }
 149
 150     }
 151
 152   return trybind_result;
 153 }
 154
 155 template <ACE_T1> int
 156 ACE_Hash_Cache_Map_Manager<ACE_T2>::find (const KEY &key,
 157                                        CACHE_ENTRY *&entry)
 158 {
 159   // Lookup the key and populate the <value>.
 160   int find_result = this->map_.find (key,
 161                                      entry);
 162
 163   if (find_result != -1)
 164     {
 165
 166       int result = this->caching_strategy_.notify_find (find_result,
 167                                                         entry->int_id_.second ());
 168
 169       // Unless the find and notification operations go thru, this
 170       // method is not successful.
 171       if (result == -1)
 172         find_result = -1;
 173       else
 174         find_result = 0;
 175
 176     }
 177
 178   return find_result;
 179 }
 180
 181 template <ACE_T1> int
 182 ACE_Hash_Cache_Map_Manager<ACE_T2>::find (const KEY &key,
 183                                        VALUE &value)
 184 {
 185   CACHE_ENTRY *entry = 0;
 186
 187   int result = this->find (key,
 188                            entry);
 189
 190   if (result != -1)
 191     {
 192       value = entry->int_id_.first ();
 193     }
 194
 195   return result;
 196 }
 197
 198 template <ACE_T1> int
 199 ACE_Hash_Cache_Map_Manager<ACE_T2>::find (const KEY &key)
 200 {
 201   CACHE_ENTRY *entry = 0;
 202
 203   return this->find (key,
 204                      entry);
 205 }
 206
 207 template <ACE_T1> int
 208 ACE_Hash_Cache_Map_Manager<ACE_T2>::unbind (CACHE_ENTRY *entry)
 209 {
 210   // Remove the entry from the cache.
 211   int unbind_result = this->map_.unbind (entry);
 212
 213   if (unbind_result != -1)
 214     {
 215
 216       int result = this->caching_strategy_.notify_unbind (unbind_result,
 217                                                           entry->int_id_.second ());
 218
 219       if (result == -1)
 220         unbind_result = -1;
 221
 222     }
 223
 224   return unbind_result;
 225 }
 226
 227 ACE_END_VERSIONED_NAMESPACE_DECL
 228
 229 #undef ACE_T1
 230 #undef ACE_T2
 231
 232 #endif /* ACE_HASH_CACHE_MAP_MANAGER_T_CPP */