dep/ACE_wrappers/ace/Caching_Utility_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Caching_Utility_T.h
   6  *
   7  *  $Id: Caching_Utility_T.h 80826 2008-03-04 14:51:23Z wotte $
   8  *
   9  *  @author Kirthika Parameswaran <kirthika@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13 #ifndef ACE_CACHING_UTILITY_H
  14 #define ACE_CACHING_UTILITY_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include /**/ "ace/config-all.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 #include "ace/Global_Macros.h"
  25 #include "ace/Cleanup_Strategies_T.h"
  26
  27 // For linkers that cant grok long names.
  28 #define ACE_Pair_Caching_Utility APUTIL
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 /**
  33  * @class ACE_Pair_Caching_Utility
  34  *
  35  * @brief Defines a helper class for the Caching Strategies.
  36  *
  37  * This class defines the methods commonly used by the different
  38  * caching strategies. For instance: <clear_cache> method which
  39  * decides and purges the entry from the container.  @note This
  40  * class helps in the caching_strategies using a container
  41  * containing entries of <KEY, ACE_Pair<VALUE, attributes>>
  42  * kind. The attributes helps in deciding the entries to be
  43  * purged. The Cleanup_Strategy is the callback class to which the
  44  * entries to be cleaned up will be delegated.
  45  */
  46 template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
  47 class ACE_Pair_Caching_Utility
  48 {
  49 public:
  50
  51   typedef ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY;
  52
  53   /// Constructor.
  54   ACE_Pair_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy = 0,
  55                             int delete_cleanup_strategy = 0);
  56
  57   /// Destructor.
  58   ~ACE_Pair_Caching_Utility (void);
  59
  60   /**
  61    * Purge entries from the @a container. The Cleanup_Strategy will do the
  62    * actual job of cleanup once the entries to be cleaned up are decided.
  63    */
  64   int clear_cache (CONTAINER &container,
  65                    double purge_percent);
  66
  67 protected:
  68
  69   /// Find the entry with minimum caching attributes.
  70   void minimum (CONTAINER &container,
  71                 KEY *&key_to_remove,
  72                 VALUE *&value_to_remove);
  73
  74   /// The cleanup strategy which can be used to destroy the entries of
  75   /// the container.
  76   CLEANUP_STRATEGY *cleanup_strategy_;
  77
  78   /// Whether the cleanup_strategy should be destroyed or not.
  79   int delete_cleanup_strategy_;
  80
  81   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Pair_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
  82   ACE_UNIMPLEMENTED_FUNC (ACE_Pair_Caching_Utility (const ACE_Pair_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
  83 };
  84
  85 ////////////////////////////////////////////////////////////////////////////////
  86 #define ACE_Recyclable_Handler_Caching_Utility ARHUTIL
  87
  88 /**
  89  * @class ACE_Recyclable_Handler_Caching_Utility
  90  *
  91  * @brief Defines a helper class for the Caching Strategies.
  92  *
  93  * This class defines the methods commonly used by the different
  94  * caching strategies. For instance: <clear_cache> method which
  95  * decides and purges the entry from the container.  @note This
  96  * class helps in the caching_strategies using a container
  97  * containing entries of <KEY, Svc_Handler> kind. The attributes
  98  * helps in deciding the entries to be purged. The
  99  * Cleanup_Strategy is the callback class to which the entries to
 100  * be cleaned up will be delegated.
 101  */
 102 template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
 103 class ACE_Recyclable_Handler_Caching_Utility
 104 {
 105
 106 public:
 107
 108   typedef ACE_Recyclable_Handler_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY;
 109   typedef ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY_BASE;
 110
 111   /// Constructor.
 112   ACE_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy = 0,
 113                                           int delete_cleanup_strategy = 0);
 114
 115   /// Destructor.
 116   ~ACE_Recyclable_Handler_Caching_Utility (void);
 117
 118   /**
 119    * Purge entries from the <container>. The Cleanup_Strategy will do
 120    * the actual job of cleanup once the entries to be cleaned up are
 121    * decided.
 122    */
 123   int clear_cache (CONTAINER &container,
 124                    double purge_percent);
 125
 126 protected:
 127
 128   /// Find the entry with minimum caching attributes.
 129   void minimum (CONTAINER &container,
 130                 KEY *&key_to_remove,
 131                 VALUE *&value_to_remove);
 132
 133   /// This is the default Cleanup Strategy for this utility.
 134   CLEANUP_STRATEGY_BASE *cleanup_strategy_;
 135
 136   /// Whether the cleanup_strategy should be destroyed or not.
 137   int delete_cleanup_strategy_;
 138
 139 private:
 140   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Recyclable_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 141   ACE_UNIMPLEMENTED_FUNC (ACE_Recyclable_Handler_Caching_Utility (const ACE_Recyclable_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 142 };
 143
 144 ///////////////////////////////////////////////////////////////////////////
 145 #define ACE_Refcounted_Recyclable_Handler_Caching_Utility ARRHUTIL
 146
 147 /**
 148  * @class ACE_Refcounted_Recyclable_Handler_Caching_Utility
 149  *
 150  * @brief Defines a helper class for the Caching Strategies.
 151  *
 152  * This class defines the methods commonly used by the different
 153  * caching strategies. For instance: clear_cache () method which
 154  * decides and purges the entry from the container.  @note This
 155  * class helps in the caching_strategies using a container
 156  * containing entries of <Refcounted_KEY,
 157  * Recyclable_Connection_Handler> kind. The attributes helps in
 158  * deciding the entries to be purged. The Cleanup_Strategy is the
 159  * callback class to which the entries to be cleaned up will be
 160  * delegated.
 161  */
 162 template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
 163 class ACE_Refcounted_Recyclable_Handler_Caching_Utility
 164 {
 165
 166 public:
 167
 168   typedef ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY;
 169   typedef ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY_BASE;
 170
 171   /// Constructor.
 172   ACE_Refcounted_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy = 0,
 173                                                      int delete_cleanup_strategy = 0);
 174
 175   /// Destructor.
 176   ~ACE_Refcounted_Recyclable_Handler_Caching_Utility (void);
 177
 178   /**
 179    * Purge entries from the <container>. The Cleanup_Strategy will do
 180    * the actual job of cleanup once the entries to be cleaned up are
 181    * decided.
 182    */
 183   int clear_cache (CONTAINER &container,
 184                    double purge_percent);
 185
 186 protected:
 187
 188   /// Find the entry with minimum caching attributes.
 189   void minimum (CONTAINER &container,
 190                 KEY *&key_to_remove,
 191                 VALUE *&value_to_remove);
 192
 193   /// This is the default Cleanup Strategy for this utility.
 194   CLEANUP_STRATEGY_BASE *cleanup_strategy_;
 195
 196   /// Whether the cleanup_strategy should be destroyed or not.
 197   int delete_cleanup_strategy_;
 198
 199   /**
 200    * This figure denotes the number of entries are there in the
 201    * container which have been marked as closed already but might
 202    * not have been unbound from the container.
 203    */
 204   size_t marked_as_closed_entries_;
 205
 206 private:
 207   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 208   ACE_UNIMPLEMENTED_FUNC (ACE_Refcounted_Recyclable_Handler_Caching_Utility (const ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 209 };
 210
 211 ////////////////////////////////////////////////////////////////////////////////////////
 212
 213 /**
 214  * @class ACE_Handler_Caching_Utility
 215  *
 216  * @brief Defines a helper class for the Caching Strategies.
 217  *
 218  * This class defines the methods commonly used by the different
 219  * caching strategies. For instance: <clear_cache> method which
 220  * decides and purges the entry from the container.  @note This
 221  * class helps in the caching_strategies using a container
 222  * containing entries of <KEY, HANDLER> kind where the HANDLER
 223  * contains the caching attributes which help in deciding the
 224  * entries to be purged. The Cleanup_Strategy is the callback
 225  * class to which the entries to be cleaned up will be delegated.
 226  */
 227 template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
 228 class ACE_Handler_Caching_Utility
 229 {
 230 public:
 231
 232   typedef ACE_Handler_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY;
 233   typedef ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY_BASE;
 234
 235   /// Constructor.
 236   ACE_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy = 0,
 237                                int delete_cleanup_strategy = 0);
 238
 239   /// Destructor.
 240   ~ACE_Handler_Caching_Utility (void);
 241
 242   /**
 243    * Purge entries from the <container>. The Cleanup_Strategy will do
 244    * the actual job of cleanup once the entries to be cleaned up are
 245    * decided.
 246    */
 247   int clear_cache (CONTAINER &container,
 248                    double purge_percent);
 249
 250 protected:
 251
 252   /**
 253    * Find the entry with minimum caching attributes.  This is handler
 254    * specific since this utility is to be used very specifically for
 255    * handler who have caching_attributes for server side acched
 256    * connection management.
 257    */
 258   void minimum (CONTAINER &container,
 259                 KEY *&key_to_remove,
 260                 VALUE *&value_to_remove);
 261
 262   /// The cleanup strategy which can be used to destroy the entries of
 263   /// the container.
 264   CLEANUP_STRATEGY_BASE *cleanup_strategy_;
 265
 266   /// Whether the cleanup_strategy should be destroyed or not.
 267   int delete_cleanup_strategy_;
 268
 269 private:
 270   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 271   ACE_UNIMPLEMENTED_FUNC (ACE_Handler_Caching_Utility (const ACE_Handler_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 272 };
 273
 274 ///////////////////////////////////////////////////////////////////////////
 275 #define ACE_Null_Caching_Utility ANUTIL
 276 /**
 277  * @class ACE_Null_Caching_Utility
 278  *
 279  * @brief Defines a dummy helper class for the Caching Strategies.
 280  *
 281  * This class defines the methods commonly used by the different
 282  * caching strategies. For instance: <clear_cache> method which
 283  * decides and purges the entry from the container.  @note This
 284  * class is be used with the Null_Caching_Strategy. The
 285  * Cleanup_Strategy is the callback class to which the entries to
 286  * be cleaned up will be delegated.
 287  */
 288 template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
 289 class ACE_Null_Caching_Utility
 290 {
 291 public:
 292
 293   typedef ACE_Null_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY;
 294   typedef ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> CLEANUP_STRATEGY_BASE;
 295
 296   /// Constructor.
 297   ACE_Null_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy = 0,
 298                             int delete_cleanup_strategy = 0);
 299
 300   /// Destructor.
 301   ~ACE_Null_Caching_Utility (void);
 302
 303   /**
 304    * Purge entries from the <container>. The Cleanup_Strategy will do
 305    * the actual job of cleanup once the entries to be cleaned up are
 306    * decided. @note Here it is a no-op.
 307    */
 308   int clear_cache (CONTAINER &container,
 309                    double purge_percent);
 310
 311 protected:
 312
 313   /**
 314    * Find the entry with minimum caching attributes.  This is handler
 315    * specific since this utility is to be used very specifically for
 316    * handler who have caching_attributes for server side acched
 317    * connection management.@note Here it is a no-op.
 318    */
 319   void minimum (CONTAINER &container,
 320                 KEY *&key_to_remove,
 321                 VALUE *&value_to_remove);
 322
 323   /// The cleanup strategy which can be used to destroy the entries of
 324   /// the container.
 325   CLEANUP_STRATEGY_BASE *cleanup_strategy_;
 326
 327   /// Whether the cleanup_strategy should be destroyed or not.
 328   int delete_cleanup_strategy_;
 329
 330 private:
 331   ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Null_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 332   ACE_UNIMPLEMENTED_FUNC (ACE_Null_Caching_Utility (const ACE_Null_Caching_Utility<KEY,VALUE,CONTAINER,ITERATOR,ATTRIBUTES> &))
 333 };
 334
 335 ACE_END_VERSIONED_NAMESPACE_DECL
 336
 337 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
 338 #include "ace/Caching_Utility_T.cpp"
 339 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
 340
 341 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
 342 #pragma implementation ("Caching_Utility_T.cpp")
 343 #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
 344
 345 #include /**/ "ace/post.h"
 346
 347 #endif /* ACE_CACHING_UTILITY_H */