ACE/ace/Caching_Strategies_T.inl

   1 // -*-C++-*-
   2 //
   3 //////////////////////////////////////////////////////////////////////////////////
   4
   5 #include "ace/OS_Memory.h"
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE
  10 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::ACE_Caching_Strategy_Adapter (IMPLEMENTATION *implementation,
  11                                                                                                          bool delete_implementation)
  12   : implementation_ (implementation),
  13     delete_implementation_ (delete_implementation)
  14 {
  15   if (this->implementation_ == 0)
  16     {
  17       ACE_NEW (this->implementation_,
  18                IMPLEMENTATION);
  19       this->delete_implementation_ = true;
  20     }
  21 }
  22
  23 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE
  24 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::~ACE_Caching_Strategy_Adapter ()
  25 {
  26   if (this->delete_implementation_)
  27     {
  28       delete this->implementation_;
  29       this->delete_implementation_ = false;
  30       this->implementation_ = 0;
  31     }
  32 }
  33
  34 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE ATTRIBUTES
  35 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::attributes ()
  36 {
  37   return this->implementation_->attributes ();
  38 }
  39
  40 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE double
  41 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::purge_percent ()
  42 {
  43   return this->implementation_->purge_percent ();
  44 }
  45
  46 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE void
  47 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::purge_percent (double percentage)
  48 {
  49   this->implementation_->purge_percent (percentage);
  50 }
  51
  52 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE int
  53 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::notify_bind (int result,
  54                                                                                         const ATTRIBUTES &attr)
  55 {
  56   return this->implementation_->notify_bind (result,
  57                                              attr);
  58 }
  59
  60 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE int
  61 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::notify_find (int result,
  62                                                                                         ATTRIBUTES &attr)
  63 {
  64   return this->implementation_->notify_find (result,
  65                                              attr);
  66 }
  67
  68 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE int
  69 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::notify_unbind (int result,
  70                                                                                           const ATTRIBUTES &attr)
  71 {
  72   return this->implementation_->notify_unbind (result,
  73                                                attr);
  74 }
  75
  76 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE int
  77 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::notify_trybind (int result,
  78                                                                                            ATTRIBUTES &attr)
  79 {
  80   return this->implementation_->notify_trybind (result,
  81                                                 attr);
  82 }
  83
  84 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE int
  85 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::notify_rebind (int result,
  86                                                                                           const ATTRIBUTES &attr)
  87 {
  88   return this->implementation_->notify_rebind (result,
  89                                                attr);
  90 }
  91
  92 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE IMPLEMENTATION &
  93 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::implementation ()
  94 {
  95   return *this->implementation_;
  96 }
  97
  98 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE CACHING_UTILITY &
  99 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::caching_utility ()
 100 {
 101   return this->implementation_->caching_utility ();
 102 }
 103
 104 template<class ATTRIBUTES, class CACHING_UTILITY, class IMPLEMENTATION> ACE_INLINE void
 105 ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, IMPLEMENTATION>::dump () const
 106 {
 107 #if defined (ACE_HAS_DUMP)
 108   ACE_TRACE ("ACE_Caching_Strategy_Adapter::dump");
 109
 110   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 111   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 112 #endif /* ACE_HAS_DUMP */
 113 }
 114
 115 //////////////////////////////////////////////////////////////////////////////////
 116
 117 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE ATTRIBUTES
 118 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::attributes ()
 119 {
 120   return this->timer_;
 121 }
 122
 123 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE double
 124 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent ()
 125 {
 126   return this->purge_percent_;
 127 }
 128
 129 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 130 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent (double percentage)
 131 {
 132   this->purge_percent_ = percentage;
 133 }
 134
 135 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 136 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_bind (
 137   int result,
 138   const ATTRIBUTES & /* attr */)
 139 {
 140   if (result == 0)
 141     ++this->timer_;
 142
 143   return result;
 144 }
 145
 146 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 147 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_find (
 148   int result,
 149   ATTRIBUTES &attr)
 150 {
 151   if (result == 0)
 152     {
 153       attr = this->timer_;
 154       ++this->timer_;
 155     }
 156
 157   return result;
 158 }
 159
 160 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 161 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_unbind (
 162   int result,
 163   const ATTRIBUTES & /* attr */)
 164 {
 165   return result;
 166 }
 167
 168 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 169 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_trybind (
 170   int result,
 171   ATTRIBUTES & /* attr */)
 172 {
 173   return result;
 174 }
 175
 176 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 177 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_rebind (
 178   int result,
 179   const ATTRIBUTES & /* attr */)
 180 {
 181   if (result == 0)
 182     ++this->timer_;
 183
 184   return result;
 185 }
 186
 187 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE CACHING_UTILITY &
 188 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::caching_utility ()
 189 {
 190   return this->caching_utility_;
 191 }
 192
 193 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 194 ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::dump () const
 195 {
 196 #if defined (ACE_HAS_DUMP)
 197   ACE_TRACE ("ACE_LRU_Caching_Strategy::dump");
 198
 199   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 200   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("timer_ = %d "), this->timer_));
 201   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 202 #endif /* ACE_HAS_DUMP */
 203 }
 204
 205 //////////////////////////////////////////////////////////////////////////////////
 206
 207 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE ATTRIBUTES
 208 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::attributes ()
 209 {
 210   return 0;
 211 }
 212
 213 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE double
 214 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent ()
 215 {
 216   return this->purge_percent_;
 217 }
 218
 219 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 220 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent (double percentage)
 221 {
 222   this->purge_percent_ = percentage;
 223 }
 224
 225 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 226 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_bind (int result,
 227                                                                     const ATTRIBUTES & /* attr */)
 228 {
 229
 230   return result;
 231 }
 232
 233 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 234 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_find (int result,
 235                                                                     ATTRIBUTES &attr)
 236 {
 237   if (result == 0)
 238     ++attr;
 239
 240   return result;
 241 }
 242
 243 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 244 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_trybind (int result,
 245                                                                        ATTRIBUTES & /* attr */)
 246 {
 247   return result;
 248 }
 249
 250 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 251 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_rebind (int result,
 252                                                                       const ATTRIBUTES & /* attr */)
 253 {
 254   return result;
 255 }
 256
 257 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 258 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_unbind (int result,
 259                                                                       const ATTRIBUTES & /* attr */)
 260 {
 261   return result;
 262 }
 263
 264 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE CACHING_UTILITY &
 265 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::caching_utility ()
 266 {
 267   return this->caching_utility_;
 268 }
 269
 270 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 271 ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::dump () const
 272 {
 273 #if defined (ACE_HAS_DUMP)
 274   ACE_TRACE ("ACE_LFU_Caching_Strategy::dump");
 275
 276   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 277   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 278 #endif /* ACE_HAS_DUMP */
 279 }
 280
 281 //////////////////////////////////////////////////////////////////////////////////////
 282
 283 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE ATTRIBUTES
 284 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::attributes ()
 285 {
 286   return this->order_;
 287 }
 288
 289 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE double
 290 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent ()
 291 {
 292   return this->purge_percent_;
 293 }
 294
 295 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 296 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent (double percentage)
 297 {
 298   this->purge_percent_ = percentage;
 299 }
 300
 301 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 302 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_bind (int result,
 303                                                                      const ATTRIBUTES &attr)
 304 {
 305   ACE_UNUSED_ARG (attr);
 306
 307   if (result == 0)
 308     ++this->order_;
 309
 310   return result;
 311 }
 312
 313 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 314 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_find (int result,
 315                                                                      ATTRIBUTES &attr)
 316 {
 317   ACE_UNUSED_ARG (attr);
 318
 319   return result;
 320 }
 321
 322 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 323 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_unbind (int result,
 324                                                                        const ATTRIBUTES &attr)
 325 {
 326   ACE_UNUSED_ARG (attr);
 327
 328   return result;
 329 }
 330
 331 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 332 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_trybind (int result,
 333                                                                         ATTRIBUTES &attr)
 334 {
 335   ACE_UNUSED_ARG (attr);
 336
 337   return result;
 338 }
 339
 340 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 341 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_rebind (int result,
 342                                                                        const ATTRIBUTES &attr)
 343 {
 344   ACE_UNUSED_ARG (attr);
 345
 346   if (result == 0)
 347     ++this->order_;
 348
 349   return result;
 350 }
 351
 352 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE CACHING_UTILITY &
 353 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::caching_utility ()
 354 {
 355   return this->caching_utility_;
 356 }
 357
 358 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 359 ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::dump () const
 360 {
 361 #if defined (ACE_HAS_DUMP)
 362   ACE_TRACE ("ACE_FIFO_Caching_Strategy::dump");
 363
 364   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 365   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("order_ = %d "), this->order_));
 366   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 367 #endif /* ACE_HAS_DUMP */
 368 }
 369
 370 //////////////////////////////////////////////////////////////////////////////////
 371
 372 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE ATTRIBUTES
 373 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::attributes ()
 374 {
 375   return 0;
 376 }
 377
 378 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE double
 379 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent ()
 380 {
 381   return 0;
 382 }
 383
 384 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 385 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::purge_percent (double percentage)
 386 {
 387   ACE_UNUSED_ARG (percentage);
 388 }
 389
 390 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 391 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_bind (int result,
 392                                                                      const ATTRIBUTES &attr)
 393 {
 394   ACE_UNUSED_ARG (attr);
 395
 396   return result;
 397 }
 398
 399 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 400 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_find (int result,
 401                                                                      ATTRIBUTES &attr)
 402 {
 403   ACE_UNUSED_ARG (attr);
 404
 405   return result;
 406 }
 407
 408 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 409 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_unbind (int result,
 410                                                                        const ATTRIBUTES &attr)
 411 {
 412   ACE_UNUSED_ARG (attr);
 413
 414   return result;
 415 }
 416
 417 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 418 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_trybind (int result,
 419                                                                         ATTRIBUTES &attr)
 420 {
 421   ACE_UNUSED_ARG (attr);
 422
 423   return result;
 424 }
 425
 426 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE int
 427 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::notify_rebind (int result,
 428                                                                        const ATTRIBUTES &attr)
 429 {
 430   ACE_UNUSED_ARG (attr);
 431
 432   return result;
 433 }
 434
 435 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE CACHING_UTILITY &
 436 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::caching_utility ()
 437 {
 438   return this->caching_utility_;
 439 }
 440
 441 template<class ATTRIBUTES, class CACHING_UTILITY> ACE_INLINE void
 442 ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>::dump () const
 443 {
 444 #if defined (ACE_HAS_DUMP)
 445   ACE_TRACE ("ACE_Null_Caching_Strategy::dump");
 446
 447   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 448   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 449 #endif /* ACE_HAS_DUMP */
 450 }
 451
 452 ACE_END_VERSIONED_NAMESPACE_DECL
 453
 454 //////////////////////////////////////////////////////////////////////////////////