ACE/protocols/ace/INet/ConnectionCache.h

   1 /**
   2  * @file ConnectionCache.h
   3  *
   4  * @author Martin Corino <mcorino@remedy.nl>
   5  */
   6
   7 #ifndef ACE_INET_CONNECTION_CACHE_H
   8 #define ACE_INET_CONNECTION_CACHE_H
   9
  10 #include /**/ "ace/pre.h"
  11
  12 #include "ace/Synch_Traits.h"
  13 #include "ace/Thread_Mutex.h"
  14 #include "ace/Condition_Thread_Mutex.h"
  15 #include "ace/Null_Mutex.h"
  16 #include "ace/Hash_Map_Manager_T.h"
  17 #include "ace/INet/INet_Export.h"
  18
  19 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  20
  21 namespace ACE
  22   {
  23     namespace INet
  24       {
  25         /**
  26         * @class ACE_INet_ConnectionKey
  27         *
  28         * @brief Base class for connection keys.
  29         *
  30         */
  31         class ACE_INET_Export ConnectionKey
  32           {
  33             public:
  34               ConnectionKey ();
  35               virtual ~ConnectionKey ();
  36
  37               bool operator ==(const ConnectionKey& key) const;
  38
  39               bool operator !=(const ConnectionKey& key) const;
  40
  41               virtual u_long hash () const = 0;
  42
  43               virtual ConnectionKey* duplicate () const = 0;
  44
  45             protected:
  46               virtual bool equal (const ConnectionKey& key) const = 0;
  47           };
  48
  49         /**
  50         * @class ACE_INet_ConnectionCacheKey
  51         *
  52         * @brief Holder class for connection keys.
  53         *
  54         * Implements non-copying holder object used as ext_id in
  55         * connection cache map.
  56         */
  57         class ConnectionCacheKey
  58           {
  59             public:
  60               ConnectionCacheKey ();
  61               ConnectionCacheKey (const ConnectionKey& key);
  62               ConnectionCacheKey (const ConnectionCacheKey& cachekey);
  63               virtual ~ConnectionCacheKey ();
  64
  65               ConnectionCacheKey& operator =(const ConnectionCacheKey& cachekey);
  66
  67               bool operator ==(const ConnectionCacheKey& cachekey) const;
  68
  69               bool operator !=(const ConnectionCacheKey& cachekey) const;
  70
  71               u_long hash () const;
  72
  73               const ConnectionKey& key () const;
  74
  75             private:
  76               ConnectionKey* key_;
  77               bool delete_key_;
  78           };
  79
  80         /**
  81         * @class ACE_INet_ConnectionHolder
  82         *
  83         * @brief Generic base for connection wrappers.
  84         *
  85         */
  86         class ACE_INET_Export ConnectionHolder
  87           {
  88             public:
  89               virtual ~ConnectionHolder ();
  90             protected:
  91               ConnectionHolder ();
  92           };
  93
  94
  95         /**
  96         * @class ACE_INet_ConnectionFactory
  97         *
  98         * @brief Base class for connection factories.
  99         *
 100         * Derived classes create specific connections and
 101         * return those for caching wrapped in a connection
 102         * holder.
 103         */
 104         class ACE_INET_Export ConnectionFactory
 105           {
 106             public:
 107               ConnectionFactory ();
 108               virtual ~ConnectionFactory ();
 109
 110               virtual ConnectionHolder* create_connection (
 111                   const ConnectionKey& key) const = 0;
 112           };
 113
 114
 115         /**
 116         * @class ACE_INet_ConnectionCacheValue
 117         *
 118         * @brief Holder class for connections.
 119         *
 120         * Implements non-copying holder object maintaining
 121         * connection state used as int_id in connection
 122         * cache map.
 123         */
 124         class ConnectionCacheValue
 125           {
 126             public:
 127               enum State
 128                 {
 129                   CST_NONE,
 130                   CST_INIT,
 131                   CST_IDLE,
 132                   CST_BUSY,
 133                   CST_CLOSED
 134                 };
 135
 136               typedef ConnectionHolder connection_type;
 137
 138               ConnectionCacheValue ();
 139               explicit ConnectionCacheValue (connection_type* connection);
 140               ConnectionCacheValue (const ConnectionCacheValue& cacheval);
 141
 142               ConnectionCacheValue& operator =(const ConnectionCacheValue& cacheval);
 143
 144               bool operator == (const ConnectionCacheValue& cacheval) const;
 145
 146               bool operator != (const ConnectionCacheValue& cacheval) const;
 147
 148               connection_type* connection ();
 149
 150               const connection_type* connection () const;
 151
 152               void connection (connection_type* conn);
 153
 154               State state () const;
 155
 156               void state (State st);
 157
 158             private:
 159               State state_;
 160               connection_type* connection_;
 161           };
 162
 163
 164         /**
 165         * @class ACE_INet_ConnectionCache
 166         *
 167         * @brief Implements a cache for INet connection objects.
 168         *
 169         */
 170         class ACE_INET_Export ConnectionCache
 171           {
 172             public:
 173               typedef ConnectionHolder connection_type;
 174               typedef ConnectionFactory factory_type;
 175
 176               typedef ACE_Hash_Map_Manager_Ex <ConnectionCacheKey,
 177                                                ConnectionCacheValue,
 178                                                ACE_Hash<ConnectionCacheKey>,
 179                                                ACE_Equal_To<ConnectionCacheKey>,
 180                                                ACE_SYNCH_NULL_MUTEX> map_type;
 181
 182               typedef map_type::iterator map_iter_type;
 183
 184               typedef ACE_Hash_Map_Entry <ConnectionCacheKey,
 185                                           ConnectionCacheValue> map_entry_type;
 186
 187               /// Constructor
 188               ConnectionCache(size_t size = ACE_DEFAULT_MAP_SIZE);
 189
 190               /// Destructor
 191               ~ConnectionCache ();
 192
 193               /// Claim a connection from the cache.
 194               /// Creates a new connection using <connection_factory>
 195               /// if the cache does not contain a matching entry for
 196               /// <key>.
 197               /// If <wait> is true and the state of the matching
 198               /// connection is BUSY the method will block waiting for
 199               /// connection to become available.
 200               /// Returns true if a connection could be successfully
 201               /// claimed and sets <connection> to the claimed connection.
 202               /// Returns false otherwise.
 203               bool claim_connection(const ConnectionKey& key,
 204                                     connection_type*& connection,
 205                                     const factory_type& connection_factory,
 206                                     bool wait = true);
 207
 208               /// Release a previously claimed connection making it
 209               /// available for renewed claiming.
 210               /// Returns true if the connection was successfully released.
 211               bool release_connection(const ConnectionKey& key,
 212                                     connection_type* connection);
 213
 214               /// Close a previously claimed connection.
 215               /// Deletes the actual connection object and marks the cache entry
 216               /// as CLOSED.
 217               /// Returns true is the connection was successfully closed.
 218               bool close_connection(const ConnectionKey& key,
 219                                     connection_type* connection);
 220
 221               /// Returns true if the cache contains a connection matching
 222               /// <key>. Cache entries with state CLOSED are not considered.
 223               /// Returns false otherwise.
 224               bool has_connection (const ConnectionKey& key);
 225
 226               /// Unconditionally closes all active connections.
 227               void close_all_connections ();
 228
 229               /// Returns the number of registered cache entries (including CLOSED).
 230               size_t current_size () const;
 231
 232             private:
 233               /// Updates cache entry state
 234               bool set_connection (const ConnectionKey& key,
 235                                    const ConnectionCacheValue& cacheval);
 236
 237               /// Attempts to claim an existing connection.
 238               /// Returns true and sets @a connection if successful.
 239               /// Returns false otherwise.
 240               /// Does not wait when no connection available.
 241               bool claim_existing_connection(const ConnectionKey& key,
 242                                              connection_type*& connection,
 243                                              ConnectionCacheValue::State& state);
 244
 245               /// Looks up a matching cache entry for @a key and updates
 246               /// <cacheval> with the entry state if found.
 247               /// Returns true if found, false otherwise.
 248               bool find_connection (const ConnectionKey& key,
 249                                     ConnectionCacheValue& cacheval);
 250
 251
 252               mutable ACE_SYNCH_MUTEX lock_;
 253               ACE_SYNCH_CONDITION condition_;
 254               map_type cache_map_;
 255           };
 256       }
 257   }
 258
 259 ACE_END_VERSIONED_NAMESPACE_DECL
 260
 261 #if defined (__ACE_INLINE__)
 262 #include "ace/INet/ConnectionCache.inl"
 263 #endif
 264
 265 #include /**/ "ace/post.h"
 266 #endif /* ACE_INET_CONNECTION_CACHE_H */