// -*- C++ -*- //============================================================================= /** * @file Strategies_T.h * * $Id$ * * @author Douglas C. Schmidt */ //============================================================================= #ifndef ACE_STRATEGIES_T_H #define ACE_STRATEGIES_T_H #include /**/ "ace/pre.h" #include "ace/Hash_Map_Manager_T.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "ace/Reactor.h" #include "ace/Thread_Manager.h" #include "ace/Connection_Recycling_Strategy.h" #include "ace/Refcountable.h" #include "ace/Hashable.h" #include "ace/Recyclable.h" #include "ace/Reverse_Lock_T.h" // Needed for broken linkers that can't grok long symbols. #define ACE_Refcounted_Hash_Recyclable ARHR class ACE_Service_Repository; /** * @class ACE_Recycling_Strategy * * @brief Defines the interface (and default implementation) for * specifying a recycling strategy for a SVC_HANDLER. * * Acts as a consular to the Svc_Handler, preparing it for the * tough times ahead when the Svc_Handler will be recycled. */ template class ACE_Recycling_Strategy { public: // Useful STL-style traits. typedef ACE_TYPENAME SVC_HANDLER::addr_type addr_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; /// Virtual Destructor virtual ~ACE_Recycling_Strategy (void); /// Tell the Svc_Handler something about the recycler, so that it can /// reach the recycler when necessary. virtual int assign_recycler (SVC_HANDLER *svc_handler, ACE_Connection_Recycling_Strategy *recycler, const void *recycling_act); /// This allows us to prepare the svc_handler for recycling. virtual int prepare_for_recycling (SVC_HANDLER *svc_handler); }; /** * @class ACE_Creation_Strategy * * @brief Defines the interface for specifying a creation strategy for * a SVC_HANDLER. * * The default behavior is to make a new SVC_HANDLER. However, * subclasses can override this strategy to perform SVC_HANDLER * creation in any way that they like (such as creating subclass * instances of SVC_HANDLER, using a singleton, dynamically * linking the handler, etc.). */ template class ACE_Creation_Strategy { public: // Useful STL-style traits. typedef ACE_TYPENAME SVC_HANDLER::addr_type addr_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; // = Initialization and termination methods. /// Default constructor. ACE_Creation_Strategy (ACE_Thread_Manager * = 0, ACE_Reactor * = ACE_Reactor::instance ()); /// An ACE_Thread_Manager is useful when creating active objects and /// the ACE_Reactor is used to initialize the service handler's reactor. int open (ACE_Thread_Manager * = 0, ACE_Reactor * = ACE_Reactor::instance ()); virtual ~ACE_Creation_Strategy (void); // = Factory method. /** * Create a SVC_HANDLER with the appropriate creation strategy. The * default behavior of this method is to make a new if * == 0 (passing in the ), else is * unchanged. Returns -1 on failure, else 0. */ virtual int make_svc_handler (SVC_HANDLER *&sh); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Pointer to a thread manager. ACE_Thread_Manager *thr_mgr_; /// Pointer to an ACE_Reactor. ACE_Reactor *reactor_; }; /** * @class ACE_Singleton_Strategy * * @brief Defines the interface for specifying a creation strategy for * a that always returns the same (i.e., * it's a Singleton). * * Note that this class takes over the ownership of the * SVC_HANDLER passed into it as a parameter and it becomes * responsible for deleting this object. */ template class ACE_Singleton_Strategy : public ACE_Creation_Strategy { public: // Useful STL-style traits. typedef ACE_Creation_Strategy base_type; // = Initialization and termination methods. ACE_Singleton_Strategy (SVC_HANDLER * = 0, ACE_Thread_Manager * = 0); int open (SVC_HANDLER *, ACE_Thread_Manager * = 0); virtual ~ACE_Singleton_Strategy (void); // = Factory method. /// Create a Singleton SVC_HANDLER by always returning the same /// SVC_HANDLER. Returns -1 on failure, else 0. virtual int make_svc_handler (SVC_HANDLER *&); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Pointer to the Singleton svc_handler. SVC_HANDLER *svc_handler_; /// Keep track of whether we need to delete the . int delete_svc_handler_; }; /** * @class ACE_DLL_Strategy * * @brief Defines the interface for specifying a creation strategy for * a SVC_HANDLER based on dynamic linking of the SVC_HANDLER. */ template class ACE_DLL_Strategy : public ACE_Creation_Strategy { public: // Useful STL-style traits. typedef ACE_Creation_Strategy base_type; // = Intialization and termination methods. /// "Do-nothing" constructor. ACE_DLL_Strategy (void); /// Initialize the DLL strategy based upon the service's DLL /// information contained in the string. ACE_DLL_Strategy (const char dll_name[], const char factory_function[], const char svc_name[], ACE_Service_Repository *, ACE_Thread_Manager * = 0); /// Initialize the DLL strategy based upon the service's DLL /// information contained in the string. int open (const char dll_name[], const char factory_function[], const char svc_name[], ACE_Service_Repository *, ACE_Thread_Manager * = 0); // = Factory method. /// Create a SVC_HANDLER by dynamically linking it from a DLL. /// Returns -1 on failure, else 0. virtual int make_svc_handler (SVC_HANDLER *&); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: typedef ACE_Creation_Strategy inherited; /// Name of the DLL to dynamically link. char dll_name_[MAXPATHLEN + 1]; /// Name of the factory function in the shared library to use to /// obtain a pointer to the new SVC_HANDLER. char factory_function_[MAXPATHLEN + 1]; /// Name of the service. char svc_name_[MAXNAMELEN + 1]; /// Pointer to the . ACE_Service_Repository *svc_rep_; }; /** * @class ACE_Concurrency_Strategy * * @brief Defines the interface for specifying a concurrency strategy * for a SVC_HANDLER. * * Default behavior is to activate the SVC_HANDLER by calling * its method (which allows the SVC_HANDLER to define its * own concurrency strategy). However, subclasses can override * this default strategy to do more sophisticated concurrency * activations (such as creating the SVC_HANDLER as an active * object via multi-threading or multi-processing). */ template class ACE_Concurrency_Strategy { public: // Useful STL-style traits. typedef ACE_TYPENAME SVC_HANDLER::addr_type addr_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; /// Constructor ACE_Concurrency_Strategy (int flags = 0); // = Factory method. /** * Activate the with an appropriate concurrency * strategy. The default behavior of this method is to activate the * SVC_HANDLER by calling its method (which allows the * SVC_HANDLER to define its own concurrency strategy). */ virtual int activate_svc_handler (SVC_HANDLER *svc_handler, void *arg = 0); virtual ~ACE_Concurrency_Strategy (void); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Flags that are parsed to set options for the connected /// . int flags_; }; /** * @class ACE_Reactive_Strategy * * @brief Defines the interface for specifying a reactive concurrency * strategy for a SVC_HANDLER, where all upcalls to @c handle_*() * methods run in the reactor's thread of control. * * This class provides a strategy that registers the * with a . */ template class ACE_Reactive_Strategy : public ACE_Concurrency_Strategy { public: // Useful STL-style traits. typedef ACE_Concurrency_Strategy base_type; // = Intialization and termination methods. /// "Do-nothing constructor" ACE_Reactive_Strategy (int flags = 0); /// Initialize the strategy. ACE_Reactive_Strategy (ACE_Reactor *reactor, ACE_Reactor_Mask = ACE_Event_Handler::READ_MASK, int flags = 0); /// Initialize the strategy. virtual int open (ACE_Reactor *reactor, ACE_Reactor_Mask = ACE_Event_Handler::READ_MASK, int flags = 0); /// Destructor. virtual ~ACE_Reactive_Strategy (void); // = Factory method. /// Activate the by registering it with the /// and then calling it's hook. virtual int activate_svc_handler (SVC_HANDLER *svc_handler, void *arg = 0); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: typedef ACE_Concurrency_Strategy inherited; /// Pointer to the Reactor we'll use to register the . ACE_Reactor *reactor_; /// The mask that we pass to the when we register the /// . ACE_Reactor_Mask mask_; }; /** * @class ACE_Thread_Strategy * * @brief Defines the interface for specifying a concurrency strategy * for a based on multithreading. * * This class provides a strategy that manages the creation of threads * to handle requests from clients concurrently via a * thread-per-connection model. It behaves as a "thread factory", * spawning threads "on-demand" to run the service specified by a * user-supplied . */ template class ACE_Thread_Strategy : public ACE_Concurrency_Strategy { public: // Useful STL-style traits. typedef ACE_Concurrency_Strategy base_type; // = Intialization and termination methods. /// "Do-nothing constructor" ACE_Thread_Strategy (int flags = 0); /// Initialize the strategy. ACE_Thread_Strategy (ACE_Thread_Manager *tm, long thr_flags, int n_threads = 1, int flags = 0); /// Initialize the strategy. virtual int open (ACE_Thread_Manager *tm, long thr_flags, int n_threads = 1, int flags = 0); virtual ~ACE_Thread_Strategy (void); // = Factory method. /** * Activate the with an appropriate concurrency * strategy. This method activates the SVC_HANDLER by first calling * its method and then calling its method to turn * it into an active object. */ virtual int activate_svc_handler (SVC_HANDLER *svc_handler, void *arg = 0); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: typedef ACE_Concurrency_Strategy inherited; /// Thread manager for this class (must be provided). ACE_Thread_Manager *thr_mgr_; /// Flags to pass into the method. long thr_flags_; /// Number of threads to spawn. int n_threads_; }; /** * @class ACE_Process_Strategy * * @brief Defines the interface for specifying a concurrency strategy * for a based on multiprocessing. * * This class provides a strategy that manages the creation of * processes to handle requests from clients concurrently using a * process-per-connection model. It behaves as a "process factory", * using to fork threads "on-demand" to run the service * specified by a user-supplied in a separate process. */ template class ACE_Process_Strategy : public ACE_Concurrency_Strategy { public: // Useful STL-style traits. typedef ACE_Concurrency_Strategy base_type; // = Intialization and termination methods. /// Initialize the strategy. If is non-0 then set a /// flag to to avoid zombies. ACE_Process_Strategy (size_t n_processes = 1, ACE_Event_Handler *acceptor = 0, ACE_Reactor * = 0, int avoid_zombies = 0); /// Initialize the strategy. If is non-0 then set a /// flag to to avoid zombies. virtual int open (size_t n_processes = 1, ACE_Event_Handler *acceptor = 0, ACE_Reactor * = 0, int avoid_zombies = 0); virtual ~ACE_Process_Strategy (void); // = Factory method. /** * Activate the with an appropriate concurrency * strategy. This method activates the SVC_HANDLER by first forking * and then calling the method of the SVC_HANDLER in the * child. */ virtual int activate_svc_handler (SVC_HANDLER *svc_handler, void *arg = 0); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: typedef ACE_Concurrency_Strategy inherited; /// Number of processes to spawn. size_t n_processes_; /** * This is the in the parent is listening on. We need to * make sure that we remove it from the Reactor and close it down in * the child. */ ACE_Event_Handler *acceptor_; /** * This is the the child is using in conjunction with the * . We need to remove the from this * in the child. */ ACE_Reactor *reactor_; }; /** * @class ACE_Accept_Strategy * * @brief Defines the interface for specifying a passive connection * acceptance strategy for a SVC_HANDLER. * * This class provides a strategy that manages passive * connection acceptance of a client. */ template class ACE_Accept_Strategy { public: // Useful STL-style traits. typedef ACE_PEER_ACCEPTOR_ADDR addr_type; typedef ACE_PEER_ACCEPTOR acceptor_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; // = Initialization and termination methods. /// Default constructor. ACE_Accept_Strategy (ACE_Reactor *reactor = ACE_Reactor::instance ()); /// Initialize the with . ACE_Accept_Strategy (const ACE_PEER_ACCEPTOR_ADDR &local_addr, int restart = 0, ACE_Reactor *reactor = ACE_Reactor::instance ()); /// Initialize the with , indicating /// whether to if it's already in use. virtual int open (const ACE_PEER_ACCEPTOR_ADDR &local_addr, int reuse_addr = 0); /// Return the underlying ACE_HANDLE of the . virtual ACE_HANDLE get_handle (void) const; /// Return a reference to the . virtual ACE_PEER_ACCEPTOR &acceptor (void) const; virtual ~ACE_Accept_Strategy (void); // = Factory method. /// The default behavior delegates to the method of the /// PEER_ACCEPTOR. virtual int accept_svc_handler (SVC_HANDLER *); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Factory that establishes connections passively. ACE_PEER_ACCEPTOR peer_acceptor_; /// Pointer to the reactor used by the Acceptor. ACE_Reactor *reactor_; /// Needed to reopen the socket if fails. int reuse_addr_; /// Needed to reopen the socket if fails. ACE_PEER_ACCEPTOR_ADDR peer_acceptor_addr_; }; /** * @class ACE_Connect_Strategy * * @brief Defines the interface for specifying an active * connection establishment strategy for a SVC_HANDLER. * * This class provides a strategy that manages active * connection establishment to a server. */ template class ACE_Connect_Strategy { public: // Useful STL-style traits. typedef ACE_PEER_CONNECTOR_ADDR addr_type; typedef ACE_PEER_CONNECTOR connector_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; // = Initialization and termination methods. /// Default constructor. ACE_Connect_Strategy (void); /// Return a reference to the . virtual ACE_PEER_CONNECTOR &connector (void) const; virtual ~ACE_Connect_Strategy (void); // = Factory method. /// The default behavior delegates to the method of the /// . 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); /** * The default behavior delegates to the method of the * . * Please check the documentation in Connector.h for more details. */ 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); /// Dump the state of an object. void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Factory that establishes connections actively. ACE_PEER_CONNECTOR connector_; }; /** * @class ACE_Scheduling_Strategy * * @brief Defines the interface for specifying how to suspend and * resume a service . * * This class provides a strategy that allows arbitrarily * sophisticated service suspension and resumption. The default * behavior is to do nothing... */ template class ACE_Scheduling_Strategy { public: // Useful STL-style traits. typedef ACE_TYPENAME SVC_HANDLER::addr_type addr_type; typedef SVC_HANDLER handler_type; typedef ACE_TYPENAME SVC_HANDLER::stream_type stream_type; // = Initialization and termination methods. /// Constructor ACE_Scheduling_Strategy (SVC_HANDLER * = 0); /// Destructor virtual ~ACE_Scheduling_Strategy (void); // = Scheduling methods /// Suspend hook. virtual int suspend (void); /// Resume hook. virtual int resume (void); /// Dump the state of the object. virtual void dump (void) const; }; /** * @class ACE_Schedule_All_Reactive_Strategy * * @brief Defines the interface for specifying how to suspend and * resume a single-threaded reactive service . * * This class provides a strategy that suspends and resumes all * the Event_Handlers in a Reactor in one fell swoop. */ template class ACE_Schedule_All_Reactive_Strategy : public ACE_Scheduling_Strategy { public: // Useful STL-style traits. typedef ACE_Scheduling_Strategy base_type; // = Initialization and termination methods. /// Constructor ACE_Schedule_All_Reactive_Strategy (SVC_HANDLER * = 0); // = Scheduling methods /// Suspend hook. virtual int suspend (void); /// Resume hook. virtual int resume (void); /// Dump the state of the object. virtual void dump (void) const; protected: /// Reactor ACE_Reactor *reactor_; }; /** * @class ACE_Schedule_All_Threaded_Strategy * * @brief Defines the interface for specifying how to suspend and * resume a multithreaded service . * * This class provides a strategy that suspends and resumes all * the Event_Handlers controlled by a Thread_Manager in one fell swoop. */ template class ACE_Schedule_All_Threaded_Strategy : public ACE_Scheduling_Strategy { public: // Useful STL-style traits. typedef ACE_Scheduling_Strategy base_type; // = Initialization and termination methods. /// Constructor ACE_Schedule_All_Threaded_Strategy (SVC_HANDLER * = 0); // = Scheduling methods /// Suspend hook. virtual int suspend (void); /// Resume hook. virtual int resume (void); /// Dump the state of the object. virtual void dump (void) const; protected: /// Thread Manager ACE_Thread_Manager *thr_mgr_; }; /** * @class ACE_NOOP_Creation_Strategy * * @brief Implements a no-op creation strategy in order to defer * decisions regarding creation to some later point in time, such * as in connect or accept strategy. * * An example of the use of this is in the * , which only returns a single * connection for a given endpoint. */ template class ACE_NOOP_Creation_Strategy : public ACE_Creation_Strategy { public: // Useful STL-style traits. typedef ACE_Creation_Strategy base_type; /// This is a no-op. virtual int make_svc_handler (SVC_HANDLER *&); }; /** * @class ACE_NOOP_Concurrency_Strategy * * @brief Implements a no-op activation strategy in order to avoid * calling open on a svc_handler multiple times. * * An example of the use of this is in the * , which reuses svc_handlers. * Therefore we don't want to call open on the recycled * svc_handler more than once. */ template class ACE_NOOP_Concurrency_Strategy : public ACE_Concurrency_Strategy { public: // Useful STL-style traits. typedef ACE_Concurrency_Strategy base_type; // = Factory method. /// This is a no-op. virtual int activate_svc_handler (SVC_HANDLER *svc_handler, void *arg = 0); }; template class ACE_Refcounted_Hash_Recyclable : public ACE_Refcountable, public ACE_Hashable, public ACE_Recyclable { public: /// Default constructor. ACE_Refcounted_Hash_Recyclable (void); /// Constructor. ACE_Refcounted_Hash_Recyclable (const T &t, int refcount = 0, ACE_Recyclable_State state = ACE_RECYCLABLE_UNKNOWN); /// Destructor virtual ~ACE_Refcounted_Hash_Recyclable (void); /// Compares two instances. bool operator== (const ACE_Refcounted_Hash_Recyclable &rhs) const; bool operator!= (const ACE_Refcounted_Hash_Recyclable &rhs) const; T &subject (); protected: /// Computes and returns hash value. u_long hash_i (void) const; T t_; }; /** * @class ACE_Cached_Connect_Strategy * * @brief 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 . * It's added value is re-use of established connections. */ template class ACE_Cached_Connect_Strategy : public ACE_Connection_Recycling_Strategy, public ACE_Connect_Strategy { public: // Useful STL-style traits. typedef ACE_Creation_Strategy creation_strategy_type; typedef ACE_Connect_Strategy connect_strategy_type; typedef ACE_Concurrency_Strategy concurrency_strategy_type; typedef ACE_Recycling_Strategy recycling_strategy_type; // = Define some useful (old style) traits. typedef ACE_Creation_Strategy CREATION_STRATEGY; typedef ACE_Concurrency_Strategy CONCURRENCY_STRATEGY; typedef ACE_Recycling_Strategy RECYCLING_STRATEGY; // = Super class typedef ACE_Connect_Strategy CONNECT_STRATEGY; typedef ACE_Cached_Connect_Strategy SELF; /// Constructor ACE_Cached_Connect_Strategy (ACE_Creation_Strategy *cre_s = 0, ACE_Concurrency_Strategy *con_s = 0, ACE_Recycling_Strategy *rec_s = 0, MUTEX *mutex = 0, int delete_mutex = 0); /// Destructor virtual ~ACE_Cached_Connect_Strategy (void); /// This methods allow you to change the strategies used by the /// cached connector. virtual int open (ACE_Creation_Strategy *cre_s, ACE_Concurrency_Strategy *con_s, ACE_Recycling_Strategy *rec_s); /// Template method for making a new virtual int make_svc_handler (SVC_HANDLER *&sh); /// Template method for activating a new virtual int activate_svc_handler (SVC_HANDLER *svc_handler); /// Template method for setting the recycler information of the /// svc_handler. virtual int assign_recycler (SVC_HANDLER *svc_handler, ACE_Connection_Recycling_Strategy *recycler, const void *recycling_act); /// Template method for preparing the svc_handler for recycling. virtual int prepare_for_recycling (SVC_HANDLER *svc_handler); /** * Checks to see if there is already a in the cache * connected to the . If so, we return this pointer. * Otherwise we establish the connection, put it into the cache, and * return the 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.}> */ 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); /// Remove from cache. virtual int purge (const void *recycling_act); /// Add to cache. virtual int cache (const void *recycling_act); /// Get/Set . virtual int recycle_state (const void *recycling_act, ACE_Recyclable_State new_state); virtual ACE_Recyclable_State recycle_state (const void *recycling_act) const; /// Mark as closed. virtual int mark_as_closed (const void *recycling_act); /** * 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. */ virtual int mark_as_closed_i (const void *recycling_act); /// Cleanup hint and reset <*act_holder> to zero if . virtual int cleanup_hint (const void *recycling_act, void **act_holder = 0); // = Traits for managing the map typedef ACE_Refcounted_Hash_Recyclable REFCOUNTED_HASH_RECYCLABLE_ADDRESS; typedef ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_Null_Mutex> CONNECTION_MAP; typedef ACE_TYPENAME CONNECTION_MAP::ITERATOR CONNECTION_MAP_ITERATOR; typedef ACE_TYPENAME CONNECTION_MAP::ENTRY CONNECTION_MAP_ENTRY; typedef ACE_Reverse_Lock REVERSE_MUTEX; // = Strategy accessors virtual ACE_Creation_Strategy *creation_strategy (void) const; virtual ACE_Recycling_Strategy *recycling_strategy (void) const; virtual ACE_Concurrency_Strategy *concurrency_strategy (void) const; protected: /// Creates a new connection. 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); /// Find an idle handle. int find (REFCOUNTED_HASH_RECYCLABLE_ADDRESS &search_addr, CONNECTION_MAP_ENTRY *&entry); /// Remove from cache (non-locking version). virtual int purge_i (const void *recycling_act); /// Add to cache (non-locking version). virtual int cache_i (const void *recycling_act); /// Set (non-locking version). virtual int recycle_state_i (const void *recycling_act, ACE_Recyclable_State new_state); /// Get (non-locking version). virtual ACE_Recyclable_State recycle_state_i (const void *recycling_act) const; /// Cleanup hint and reset <*act_holder> to zero if . virtual int cleanup_hint_i (const void *recycling_act, void **act_holder); // = Helpers 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, CONNECTION_MAP_ENTRY *&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, CONNECTION_MAP_ENTRY *&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); /// Table that maintains the cache of connected s. CONNECTION_MAP connection_map_; /// Mutual exclusion for this object. MUTEX *lock_; /// Mutual exclusion for this object. int delete_lock_; /// Reverse lock. REVERSE_MUTEX *reverse_lock_; // = Strategy objects. /// Creation strategy for an . CREATION_STRATEGY *creation_strategy_; /// 1 if created the creation strategy and thus should /// delete it, else 0. int delete_creation_strategy_; /// Concurrency strategy for an . CONCURRENCY_STRATEGY *concurrency_strategy_; /// 1 if created the concurrency strategy and thus should /// delete it, else 0. int delete_concurrency_strategy_; /// Recycling strategy for an . RECYCLING_STRATEGY *recycling_strategy_; /// 1 if created the recycling strategy and thus should /// delete it, else 0. int delete_recycling_strategy_; }; #if defined (__ACE_INLINE__) #include "ace/Strategies_T.inl" #endif /* __ACE_INLINE__ */ #if defined (ACE_TEMPLATES_REQUIRE_SOURCE) #include "ace/Strategies_T.cpp" #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) #pragma implementation ("Strategies_T.cpp") #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ #include /**/ "ace/post.h" #endif /* ACE_STRATEGIES_T_H */