ACE/ace/Cleanup_Strategies_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Cleanup_Strategies_T.h
   6  *
   7  *  @author Kirthika Parameswaran <kirthika@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11 #ifndef CLEANUP_STRATEGIES_H
  12 #define CLEANUP_STRATEGIES_H
  13 #include /**/ "ace/pre.h"
  14
  15 #include /**/ "ace/config-all.h"
  16
  17 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  18 # pragma once
  19 #endif /* ACE_LACKS_PRAGMA_ONCE */
  20
  21 // For linkers that cant grok long names.
  22 #define ACE_Cleanup_Strategy ACLE
  23
  24 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 /**
  27  * @class ACE_Cleanup_Strategy
  28  *
  29  * @brief Defines a default strategy to be followed for cleaning up
  30  * entries from a map which is the container.
  31  *
  32  * By default the entry to be cleaned up is removed from the
  33  * container.
  34  */
  35 template <class KEY, class VALUE, class CONTAINER>
  36 class ACE_Cleanup_Strategy
  37 {
  38 public:
  39   /// Destructor.
  40   virtual ~ACE_Cleanup_Strategy ();
  41
  42   /// The method which will do the cleanup of the entry in the container.
  43   virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value);
  44 };
  45
  46 //////////////////////////////////////////////////////////////////////
  47 #define ACE_Recyclable_Handler_Cleanup_Strategy ARHCLE
  48
  49 /**
  50  * @class ACE_Recyclable_Handler_Cleanup_Strategy
  51  *
  52  * @brief Defines a strategy to be followed for cleaning up
  53  * entries which are svc_handlers from a container.
  54  *
  55  * The entry to be cleaned up is removed from the container.
  56  * Here, since we are dealing with svc_handlers specifically, we
  57  * perform a couple of extra operations. @note To be used when
  58  * the handler is recyclable.
  59  */
  60 template <class KEY, class VALUE, class CONTAINER>
  61 class ACE_Recyclable_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER>
  62 {
  63 public:
  64   /// The method which will do the cleanup of the entry in the container.
  65   virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value);
  66 };
  67
  68 //////////////////////////////////////////////////////////////////////
  69 #define ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy ARRHCLE
  70
  71 /**
  72  * @class ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy
  73  *
  74  * @brief Defines a strategy to be followed for cleaning up
  75  * entries which are svc_handlers from a container.
  76  *
  77  * The entry to be cleaned up is removed from the container.
  78  * Here, since we are dealing with recyclable svc_handlers with
  79  * addresses which are refcountable specifically, we perform a
  80  * couple of extra operations and do so without any locking.
  81  */
  82 template <class KEY, class VALUE, class CONTAINER>
  83 class ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER>
  84 {
  85 public:
  86   /// The method which will do the cleanup of the entry in the container.
  87   virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value);
  88 };
  89
  90 //////////////////////////////////////////////////////////////////////
  91
  92 /**
  93  * @class ACE_Handler_Cleanup_Strategy
  94  *
  95  * @brief Defines a strategy to be followed for cleaning up
  96  * entries which are svc_handlers from a container.
  97  *
  98  * The entry to be cleaned up is removed from the container.
  99  * Here, since we are dealing with svc_handlers specifically, we
 100  * perform a couple of extra operations. @note This cleanup strategy
 101  * should be used in the case when the handler has the caching
 102  * attributes.
 103  */
 104 template <class KEY, class VALUE, class CONTAINER>
 105 class ACE_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER>
 106 {
 107 public:
 108   /// The method which will do the cleanup of the entry in the container.
 109   virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value);
 110 };
 111
 112 //////////////////////////////////////////////////////////////////////
 113 #define ACE_Null_Cleanup_Strategy ANCLE
 114
 115 /**
 116  * @class ACE_Null_Cleanup_Strategy
 117  *
 118  * @brief Defines a do-nothing implementation of the cleanup strategy.
 119  *
 120  * This class simply does nothing at all! Can be used to nullify
 121  * the effect of the Cleanup Strategy.
 122  */
 123 template <class KEY, class VALUE, class CONTAINER>
 124 class ACE_Null_Cleanup_Strategy : public ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER>
 125 {
 126 public:
 127   /// The dummy cleanup method.
 128   virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value);
 129 };
 130
 131 ACE_END_VERSIONED_NAMESPACE_DECL
 132
 133 #include "ace/Cleanup_Strategies_T.cpp"
 134
 135 #include /**/ "ace/post.h"
 136 #endif /* CLEANUP_STRATEGIES_H */