Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX > Class Template Reference

A connection strategy which caches connections to peers (represented by instances), thereby allowing subsequent re-use of unused, but available, connections. More...

#include <Cached_Connect_Strategy_T.h>

Inheritance diagram for ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_Refcounted_Hash_Recyclable<
ACE_PEER_CONNECTOR_ADDR > 		REFCOUNTED_HASH_RECYCLABLE_ADDRESS
typedef ACE_Hash_Cache_Map_Manager<
REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
SVC_HANDLER *, ACE_Hash<
REFCOUNTED_HASH_RECYCLABLE_ADDRESS >,
ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >,
CACHING_STRATEGY, ATTRIBUTES > 		CONNECTION_CACHE
typedef CONNECTION_CACHE::CACHE_ENTRY CONNECTION_CACHE_ENTRY
typedef CONNECTION_CACHE::key_type KEY
typedef CONNECTION_CACHE::mapped_type VALUE
typedef ACE_Recyclable_Handler_Cleanup_Strategy<
REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
ACE_Pair< SVC_HANDLER *,
ATTRIBUTES >, ACE_Hash_Map_Manager_Ex<
REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
ACE_Pair< SVC_HANDLER *,
ATTRIBUTES >, ACE_Hash< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >,
ACE_Equal_To< REFCOUNTED_HASH_RECYCLABLE_ADDRESS >,
MUTEX > > 		CLEANUP_STRATEGY
typedef ACE_Cached_Connect_Strategy<
SVC_HANDLER, ACE_PEER_CONNECTOR_2,
MUTEX > 		CCSBASE

Public Member Functions

 ACE_Cached_Connect_Strategy_Ex (CACHING_STRATEGY &caching_s, ACE_Creation_Strategy< SVC_HANDLER > *cre_s=0, ACE_Concurrency_Strategy< SVC_HANDLER > *con_s=0, ACE_Recycling_Strategy< SVC_HANDLER > *rec_s=0, MUTEX *lock=0, int delete_lock=0)
 Constructor.

virtual ~ACE_Cached_Connect_Strategy_Ex (void)
 Destructor.

virtual int purge_connections (void)
 Explicit purging of connection entries from the connection cache.

virtual int mark_as_closed_i (const void *recycling_act)
void cleanup (void)
CACHING_STRATEGY & caching_strategy (void)

Protected Member Functions

int find (ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR > &search_addr, ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&entry)
 Find an idle handle.

virtual int purge_i (const void *recycling_act)
 Remove from cache (non-locking version).

virtual int cache_i (const void *recycling_act)
 Add to cache (non-locking version).

virtual int recycle_state_i (const void *recycling_act, ACE_Recyclable_State new_state)
 Get/Set (non-locking version).

virtual ACE_Recyclable_State recycle_state_i (const void *recycling_act) const
 Get (non-locking version).

virtual int cleanup_hint_i (const void *recycling_act, void **act_holder)
 Cleanup hint and reset <*act_holder> to zero if <act_holder != 0>.

int check_hint_i (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms, ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&entry, int &found)
virtual int find_or_create_svc_handler_i (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms, ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&entry, int &found)
virtual int connect_svc_handler_i (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms, int &found)
virtual int cached_connect (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms)

Protected Attributes

CONNECTION_CACHE connection_cache_
 Table that maintains the cache of connected s.

Detailed Description

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
class ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >

A connection strategy which caches connections to peers (represented by instances), thereby allowing subsequent re-use of unused, but available, connections.

is intended to be used as a plug-in connection strategy for ACE_Strategy_Connector. It's added value is re-use of established connections and tweaking the role of the cache as per the caching strategy.

Definition at line 48 of file Cached_Connect_Strategy_T.h.

Member Typedef Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX> ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CCSBASE
 

Definition at line 102 of file Cached_Connect_Strategy_T.h.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef ACE_Recyclable_Handler_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, ACE_Pair<SVC_HANDLER *, ATTRIBUTES>, ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, ACE_Pair<SVC_HANDLER *, ATTRIBUTES>, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, MUTEX> > ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CLEANUP_STRATEGY
 

Definition at line 99 of file Cached_Connect_Strategy_T.h.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, CACHING_STRATEGY, ATTRIBUTES> ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE
 

Definition at line 87 of file Cached_Connect_Strategy_T.h.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef CONNECTION_CACHE::CACHE_ENTRY ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY
 

Definition at line 88 of file Cached_Connect_Strategy_T.h.

Referenced by ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cache_i(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup_hint_i(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::mark_as_closed_i(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::purge_i(), and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::recycle_state_i().

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef CONNECTION_CACHE::key_type ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::KEY
 

Definition at line 89 of file Cached_Connect_Strategy_T.h.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::REFCOUNTED_HASH_RECYCLABLE_ADDRESS
 

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Reimplemented in ACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >.

Definition at line 80 of file Cached_Connect_Strategy_T.h.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
typedef CONNECTION_CACHE::mapped_type ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::VALUE
 

Definition at line 90 of file Cached_Connect_Strategy_T.h.

Constructor & Destructor Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::ACE_Cached_Connect_Strategy_Ex (  CACHING_STRATEGY &  caching_s,
ACE_Creation_Strategy< SVC_HANDLER > *  cre_s = 0,
ACE_Concurrency_Strategy< SVC_HANDLER > *  con_s = 0,
ACE_Recycling_Strategy< SVC_HANDLER > *  rec_s = 0,
MUTEX *  lock = 0,
int  delete_lock = 0
) 
 

Constructor.

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::~ACE_Cached_Connect_Strategy_Ex (  void   )  [virtual]
 

Destructor.

Definition at line 42 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup(). 

00043 {
00044   cleanup ();
00045 }

Member Function Documentation

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::cache_i (  const void *  recycling_act  )  [protected, virtual]
 

Add to cache (non-locking version).

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 374 of file Cached_Connect_Strategy_T.cpp.

References ACE_RECYCLABLE_IDLE_AND_PURGABLE, and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY. 

00375 {
00376   // The wonders and perils of ACT
00377   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00378 
00379   // Mark the <svc_handler> in the cache as not being <in_use>.
00380   // Therefore recyclable is IDLE.
00381   entry->ext_id_.recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE);
00382 
00383   return 0;
00384 }

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
virtual int ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cached_connect (  SVC_HANDLER *&  sh,
const ACE_PEER_CONNECTOR_ADDR &  remote_addr,
ACE_Time_Value *  timeout,
const ACE_PEER_CONNECTOR_ADDR &  local_addr,
int  reuse_addr,
int  flags,
int  perms
)  [protected, virtual]
 

Connection of the svc_handler with the remote host. This method also encapsulates the connection done with auto_purging under the hood. If the connect failed due to the process running out of file descriptors then, auto_purging of some connections are done from the CONNECTION_CACHE. This frees the descriptors which get used in the connect process and hence the connect operation can succeed.

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
CACHING_STRATEGY & ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::caching_strategy (  void   ) 
 

Definition at line 468 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connection_cache_. 

00469 {
00470   return this->connection_cache_.caching_strategy ();
00471 }

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
int ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::check_hint_i (  SVC_HANDLER *&  sh,
const ACE_PEER_CONNECTOR_ADDR &  remote_addr,
ACE_Time_Value *  timeout,
const ACE_PEER_CONNECTOR_ADDR &  local_addr,
int  reuse_addr,
int  flags,
int  perms,
ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&  entry,
int &  found
)  [protected]
 

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
void ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::cleanup (  void   ) 
 

Since g++ version < 2.8 arent happy with templates, this special method had to be devised to avoid memory leaks and perform cleanup of the .

Definition at line 527 of file Cached_Connect_Strategy_T.cpp.

References ACE_GUARD, ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connection_cache_, ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY, and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::purge_i().

Referenced by ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::~ACE_Cached_Connect_Strategy_Ex(). 

00528 {
00529   // Excluded other threads from changing the cache while we cleanup
00530   ACE_GUARD (MUTEX, ace_mon, *this->lock_);
00531 
00532   // Close down all cached service handlers.
00533   typename CONNECTION_CACHE::ITERATOR iter = this->connection_cache_.begin ();
00534   while (iter != this->connection_cache_.end ())
00535     {
00536       if ((*iter).second () != 0)
00537         {
00538           // save entry for future use
00539           CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *)
00540             (*iter).second ()->recycling_act ();
00541 
00542           // close handler
00543           (*iter).second ()->recycler (0, 0);
00544           (*iter).second ()->close ();
00545 
00546           // remember next iter
00547           typename CONNECTION_CACHE::ITERATOR next_iter = iter;
00548           ++next_iter;
00549 
00550           // purge the item from the hash
00551           this->purge_i (entry);
00552 
00553           // assign next iter
00554           iter  = next_iter;
00555         }
00556      else
00557        ++iter;
00558     }
00559 }

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::cleanup_hint_i (  const void *  recycling_act,
void **  act_holder
)  [protected, virtual]
 

Cleanup hint and reset <*act_holder> to zero if <act_holder != 0>.

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 434 of file Cached_Connect_Strategy_T.cpp.

References ACE_RECYCLABLE_CLOSED, ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY, and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::purge_i(). 

00436 {
00437   // Reset the <*act_holder> in the confines and protection of the
00438   // lock.
00439   if (act_holder)
00440     *act_holder = 0;
00441 
00442   // The wonders and perils of ACT
00443   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00444 
00445   // Decrement the refcount on the <svc_handler>.
00446   int refcount = entry->ext_id_.decrement ();
00447 
00448   // If the svc_handler state is closed and the refcount == 0, call
00449   // close() on svc_handler.
00450   if (entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED &&
00451       refcount == 0)
00452     {
00453       entry->int_id_.first ()->recycler (0, 0);
00454       entry->int_id_.first ()->close ();
00455       this->purge_i (entry);
00456     }
00457 
00458   return 0;
00459 }

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
virtual int ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connect_svc_handler_i (  SVC_HANDLER *&  sh,
const ACE_PEER_CONNECTOR_ADDR &  remote_addr,
ACE_Time_Value *  timeout,
const ACE_PEER_CONNECTOR_ADDR &  local_addr,
int  reuse_addr,
int  flags,
int  perms,
int &  found
)  [protected, virtual]
 

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
int ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::find (  ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR > &  search_addr,
ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&  entry
)  [protected]
 

Find an idle handle.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
virtual int ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::find_or_create_svc_handler_i (  SVC_HANDLER *&  sh,
const ACE_PEER_CONNECTOR_ADDR &  remote_addr,
ACE_Time_Value *  timeout,
const ACE_PEER_CONNECTOR_ADDR &  local_addr,
int  reuse_addr,
int  flags,
int  perms,
ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >, ACE_Pair< SVC_HANDLER *, ATTRIBUTES > > *&  entry,
int &  found
)  [protected, virtual]
 

Reimplemented in ACE_Bounded_Cached_Connect_Strategy< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >.

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::mark_as_closed_i (  const void *  recycling_act  )  [virtual]
 

Mark as closed (non-locking version). This is used during the cleanup of the connections purged.

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 422 of file Cached_Connect_Strategy_T.cpp.

References ACE_RECYCLABLE_CLOSED, and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY. 

00423 {
00424   // The wonders and perils of ACT
00425   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00426 
00427   // Mark the <svc_handler> in the cache as CLOSED.
00428   entry->ext_id_.recycle_state (ACE_RECYCLABLE_CLOSED);
00429 
00430   return 0;
00431 }

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::purge_connections (  void   )  [virtual]
 

Explicit purging of connection entries from the connection cache.

Definition at line 462 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connection_cache_. 

00463 {
00464   return this->connection_cache_.purge ();
00465 }

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::purge_i (  const void *  recycling_act  )  [protected, virtual]
 

Remove from cache (non-locking version).

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 412 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connection_cache_, ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY, and ACE_Hash_Cache_Map_Manager< KEY, VALUE, HASH_KEY, COMPARE_KEYS, CACHING_STRATEGY, ATTRIBUTES >::unbind().

Referenced by ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup(), and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup_hint_i(). 

00413 {
00414   // The wonders and perils of ACT
00415   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00416 
00417   return this->connection_cache_.unbind (entry);
00418 }

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
ACE_Recyclable_State ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::recycle_state_i (  const void *  recycling_act  )  const [protected, virtual]
 

Get (non-locking version).

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 401 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY. 

00402 {
00403   // The wonders and perils of ACT
00404   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00405 
00406   // Mark the <svc_handler> in the cache as not being <in_use>.
00407   // Therefore recyclable is IDLE.
00408   return entry->ext_id_.recycle_state ();
00409 }

template<class KEY, class VALUE, class CMAP_TYPE, class ITERATOR_IMPL, class REVERSE_ITERATOR_IMPL, class CACHING_STRATEGY, class ATTRIBUTES>
int ACE_Cached_Connect_Strategy_Ex< KEY, VALUE, CMAP_TYPE, ITERATOR_IMPL, REVERSE_ITERATOR_IMPL, CACHING_STRATEGY, ATTRIBUTES >::recycle_state_i (  const void *  recycling_act,
ACE_Recyclable_State  new_state
)  [protected, virtual]
 

Get/Set (non-locking version).

Reimplemented from ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX >.

Definition at line 387 of file Cached_Connect_Strategy_T.cpp.

References ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::CONNECTION_CACHE_ENTRY. 

00389 {
00390   // The wonders and perils of ACT
00391   CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act;
00392 
00393   // Mark the <svc_handler> in the cache as not being <in_use>.
00394   // Therefore recyclable is IDLE.
00395   entry->ext_id_.recycle_state (new_state);
00396 
00397   return 0;
00398 }

Member Data Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 , class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
CONNECTION_CACHE ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::connection_cache_ [protected]
 

Table that maintains the cache of connected s.

Definition at line 176 of file Cached_Connect_Strategy_T.h.

Referenced by ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::caching_strategy(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::cleanup(), ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::purge_connections(), and ACE_Cached_Connect_Strategy_Ex< SVC_HANDLER,, CACHING_STRATEGY, ATTRIBUTES, MUTEX >::purge_i().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:54:13 2008 for ACE by doxygen 1.3.6