ACE/ace/Caching_Utility_T.h

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