Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_Cached_Connect_Strategy Class Template Reference

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

`#include <Strategies_T.h>`

Inheritance diagram for ACE_Cached_Connect_Strategy

[legend]
Collaboration diagram for ACE_Cached_Connect_Strategy:

[legend]
List of all members.

## Public Types
typedef ACE_Cached_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX> | SELF
typedef ACE_Creation_Strategy< SVC_HANDLER> | CREATION_STRATEGY
typedef ACE_Concurrency_Strategy< SVC_HANDLER> | CONCURRENCY_STRATEGY
typedef ACE_Recycling_Strategy< SVC_HANDLER> | RECYCLING_STRATEGY
typedef ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2> | CONNECT_STRATEGY
typedef ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR> | REFCOUNTED_HASH_RECYCLABLE_ADDRESS
typedef ACE_Hash_Map_Manager< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> | CONNECTION_MAP
typedef ACE_Hash_Map_Iterator< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> | CONNECTION_MAP_ITERATOR
typedef ACE_Hash_Map_Entry< REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *> | CONNECTION_MAP_ENTRY
typedef ACE_Reverse_Lock<MUTEX> | REVERSE_MUTEX
## Public Methods
| ACE_Cached_Connect_Strategy (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 *mutex = 0, int delete_mutex = 0)
| Constructor.
virtual | ~ACE_Cached_Connect_Strategy (void)
| Destructor.
virtual int | open (ACE_Creation_Strategy<SVC_HANDLER> *cre_s, ACE_Concurrency_Strategy<SVC_HANDLER> *con_s, ACE_Recycling_Strategy<SVC_HANDLER> *rec_s)
| This methods allow you to change the strategies used by the cached connector.
virtual int | make_svc_handler (SVC_HANDLER *&sh)
| Template method for making a new <svc_handler>.
virtual int | activate_svc_handler (SVC_HANDLER *svc_handler)
| Template method for activating a new <svc_handler>.
virtual int | assign_recycler (SVC_HANDLER *svc_handler, ACE_Connection_Recycling_Strategy *recycler, const void *recycling_act)
| Template method for setting the recycler information of the svc_handler.
virtual int | prepare_for_recycling (SVC_HANDLER *svc_handler)
| Template method for preparing the svc_handler for recycling.
virtual int | connect_svc_handler (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)
virtual int | connect_svc_handler (SVC_HANDLER *&sh, SVC_HANDLER *&sh_copy, 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)
virtual int | purge (const void *recycling_act)
| Remove from cache.
virtual int | cache (const void *recycling_act)
| Add to cache.
virtual int | recycle_state (const void *recycling_act, ACE_Recyclable_State new_state)
| Get/Set <recycle_state>.
virtual ACE_Recyclable_State | recycle_state (const void *recycling_act) const
| Get/Set <recycle_state>.
virtual int | mark_as_closed (const void *recycling_act)
| Mark as closed.
virtual int | mark_as_closed_i (const void *recycling_act)
virtual int | cleanup_hint (const void *recycling_act, void **act_holder = 0)
| Cleanup hint and reset <*act_holder> to zero if .
virtual ACE_Creation_Strategy< SVC_HANDLER>* | creation_strategy (void) const
virtual ACE_Recycling_Strategy< SVC_HANDLER>* | recycling_strategy (void) const
virtual ACE_Concurrency_Strategy< SVC_HANDLER>* | concurrency_strategy (void) const
## Protected Methods
virtual int | new_connection (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)
| Creates a new connection.
int | find (ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> &search_addr, ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&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 <recycle_state> (non-locking version).
virtual ACE_Recyclable_State | recycle_state_i (const void *recycling_act) const
virtual int | cleanup_hint_i (const void *recycling_act, void **act_holder)
| Cleanup hint and reset <*act_holder> to zero if .
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>, SVC_HANDLER *> *&entry, int &found)
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>, SVC_HANDLER *> *&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)
## Protected Attributes
CONNECTION_MAP | connection_map_
| Table that maintains the cache of connected <SVC_HANDLER>s.
MUTEX* | lock_
| Mutual exclusion for this object.
int | delete_lock_
| Mutual exclusion for this object.
REVERSE_MUTEX* | reverse_lock_
| Reverse lock.
CREATION_STRATEGY* | creation_strategy_
| Creation strategy for an <Connector>.
int | delete_creation_strategy_
| 1 if <Connector> created the creation strategy and thus should delete it, else 0.
CONCURRENCY_STRATEGY* | concurrency_strategy_
| Concurrency strategy for an <Connector>.
int | delete_concurrency_strategy_
| 1 if <Connector> created the concurrency strategy and thus should delete it, else 0.
RECYCLING_STRATEGY* | recycling_strategy_
| Recycling strategy for an <Connector>.
int | delete_recycling_strategy_
| 1 if <Connector> created the recycling strategy and thus should delete it, else 0.

## Detailed Description

### template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> template class ACE_Cached_Connect_Strategy

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

is intended to be used as a plug-in connection strategy for . It's added value is re-use of established connections.

## Member Typedef Documentation

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CONCURRENCY_STRATEGY

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CONNECTION_MAP

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CONNECTION_MAP_ENTRY

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CONNECTION_MAP_ITERATOR

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CONNECT_STRATEGY

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::CREATION_STRATEGY

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Recycling_Strategy<SVC_HANDLER> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::RECYCLING_STRATEGY

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::REFCOUNTED_HASH_RECYCLABLE_ADDRESS

| Reimplemented in ACE_Cached_Connect_Strategy_Ex, and ACE_Bounded_Cached_Connect_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Reverse_Lock<MUTEX> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::REVERSE_MUTEX

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
typedef ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX> ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::SELF

## Constructor & Destructor Documentation

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX> ( | 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 * mutex = 0,
| int delete_mutex = 0 )

| Constructor.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::~ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX> ( | void )`[virtual]`

| Destructor.

## Member Function Documentation

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ASYS_INLINE int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::activate_svc_handler ( | SVC_HANDLER * svc_handler )`[virtual]`

| Template method for activating a new <svc_handler>.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ASYS_INLINE int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::assign_recycler ( | SVC_HANDLER * svc_handler,
| ACE_Connection_Recycling_Strategy * recycler,
| const void * recycling_act )`[virtual]`

| Template method for setting the recycler information of the svc_handler.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::cache ( | const void * recycling_act )`[virtual]`

| Add to cache. Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::cache_i ( | const void * recycling_act )`[protected, virtual]`

| Add to cache (non-locking version). Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,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 >,SVC_HANDLER *>*& entry,
| int & found )`[protected]`

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::cleanup_hint ( | const void * recycling_act,
| void ** act_holder = 0 )`[virtual]`

| Cleanup hint and reset <*act_holder> to zero if . Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::cleanup_hint_i ( | const void * recycling_act,
| void ** act_holder )`[protected, virtual]`

| Cleanup hint and reset <*act_holder> to zero if . Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Concurrency_Strategy< SVC_HANDLER >* ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::concurrency_strategy ( | void ) const`[virtual]`

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::connect_svc_handler ( | SVC_HANDLER *& sh,
| SVC_HANDLER *& sh_copy,
| 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 )`[virtual]`

| The default behavior delegates to the <connect> method of the <PEER_CONNECTOR::connect>. Please check the documentation in Connector.h for more details. Reimplemented from ACE_Connect_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::connect_svc_handler ( | 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 )`[virtual]`

| Checks to see if there is already a <SVC_HANDLER> in the cache connected to the <remote_addr>. If so, we return this pointer. Otherwise we establish the connection, put it into the cache, and return the <SVC_HANDLER> pointer. <[NOTE]>: the <{reuse_addr}> argument does NOT control re-use of addresses in the cache. Rather, if the underlying protocol requires a "dead time" prior to re-use of its addresses (TCP is a classic example of this), <{and}> the protocol provides a means by which to defeat the dead time, setting this argument to non-zero will defeat the dead-time requirement. <{Dev. Note: We might want to consider enhancing the interface at some point so that this also controls re-use of the cache.}> Reimplemented from ACE_Connect_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,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 in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Creation_Strategy< SVC_HANDLER >* ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::creation_strategy ( | void ) const`[virtual]`

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::find ( | ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >& search_addr,
| ACE_Hash_Map_Entry< ACE_Refcounted_Hash_Recyclable< ACE_PEER_CONNECTOR_ADDR >,SVC_HANDLER *>*& entry )`[protected]`

| Find an idle handle.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,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 >,SVC_HANDLER *>*& entry,
| int & found )`[protected]`

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ASYS_INLINE int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::make_svc_handler ( | SVC_HANDLER *& sh )`[virtual]`

| Template method for making a new <svc_handler>.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::mark_as_closed ( | const void * recycling_act )`[virtual]`

| Mark as closed. Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::mark_as_closed_i ( | const void * recycling_act )`[virtual]`

| Mark as closed (non-locking version). This method needs to be public as it is used in the cleanup of handlers where teh locked version causes a deadlock. Reimplemented from ACE_Connection_Recycling_Strategy. Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::new_connection ( | 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]`

| Creates a new connection.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::open ( | ACE_Creation_Strategy< SVC_HANDLER >* cre_s,
| ACE_Concurrency_Strategy< SVC_HANDLER >* con_s,
| ACE_Recycling_Strategy< SVC_HANDLER >* rec_s )`[virtual]`

| This methods allow you to change the strategies used by the cached connector.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ASYS_INLINE int ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::prepare_for_recycling ( | SVC_HANDLER * svc_handler )`[virtual]`

| Template method for preparing the svc_handler for recycling.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::purge ( | const void * recycling_act )`[virtual]`

| Remove from cache. Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::purge_i ( | const void * recycling_act )`[protected, virtual]`

| Remove from cache (non-locking version). Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Recyclable_State ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::recycle_state ( | const void * recycling_act ) const`[virtual]`

| Get/Set <recycle_state>. Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::recycle_state ( | const void * recycling_act,
| ACE_Recyclable_State new_state )`[virtual]`

| Get/Set <recycle_state>. Reimplemented from ACE_Connection_Recycling_Strategy.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Recyclable_State ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::recycle_state_i ( | const void * recycling_act ) const`[protected, virtual]`

| Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::recycle_state_i ( | const void * recycling_act,
| ACE_Recyclable_State new_state )`[protected, virtual]`

| Get/Set <recycle_state> (non-locking version). Reimplemented in ACE_Cached_Connect_Strategy_Ex.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
ACE_Recycling_Strategy< SVC_HANDLER >* ACE_Cached_Connect_Strategy< SVC_HANDLER,ACE_PEER_CONNECTOR_2,MUTEX >::recycling_strategy ( | void ) const`[virtual]`

## Member Data Documentation

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
CONCURRENCY_STRATEGY * ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::concurrency_strategy_`[protected]`

| Concurrency strategy for an <Connector>.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
CONNECTION_MAP ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::connection_map_`[protected]`

| Table that maintains the cache of connected <SVC_HANDLER>s.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
CREATION_STRATEGY * ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::creation_strategy_`[protected]`

| Creation strategy for an <Connector>.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::delete_concurrency_strategy_`[protected]`

| 1 if <Connector> created the concurrency strategy and thus should delete it, else 0.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::delete_creation_strategy_`[protected]`

| 1 if <Connector> created the creation strategy and thus should delete it, else 0.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::delete_lock_`[protected]`

| Mutual exclusion for this object.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
int ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::delete_recycling_strategy_`[protected]`

| 1 if <Connector> created the recycling strategy and thus should delete it, else 0.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
MUTEX * ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::lock_`[protected]`

| Mutual exclusion for this object.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
RECYCLING_STRATEGY * ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::recycling_strategy_`[protected]`

| Recycling strategy for an <Connector>.

template<classSVC_HANDLER, ACE_PEER_CONNECTOR_1, classMUTEX>
REVERSE_MUTEX * ACE_Cached_Connect_Strategy<SVC_HANDLER, , MUTEX>::reverse_lock_`[protected]`

| Reverse lock.

The documentation for this class was generated from the following files:

- Strategies_T.h
- Strategies_T.cpp
- Strategies_T.i