--- name: "ACE_Strategy_Acceptor" section: "3" platform: "linux" package: "libace-doc" version: "5.0.7-4" release: "Debian 2.2 (Potato)" platforms: ["linux"] url: "https://new.carta.tech/ACE_Strategy_Acceptor" --- # ACE\_Strategy\_Acceptor(3) Abstract factory for creating a service handler (SVC\_HANDLER), accepting into the SVC\_HANDLER, and activating the SVC\_HANDLER. ## NAME ACE\_Strategy\_Acceptor - Abstract factory for creating a service handler (SVC\_HANDLER), accepting into the SVC\_HANDLER, and activating the SVC\_HANDLER. ## SYNOPSIS ``` #include template class ACE_Strategy_Acceptor : public ACE_Acceptor { public: ACE_Strategy_Acceptor ( const ASYS_TCHAR service_name[] = 0, const ASYS_TCHAR service_description[] = 0, int use_select = 1 ); ACE_Strategy_Acceptor ( const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor * = ACE_Reactor::instance (), ACE_Creation_Strategy * = 0, ACE_Accept_Strategy * = 0, ACE_Concurrency_Strategy * = 0, ACE_Scheduling_Strategy * = 0, const ASYS_TCHAR service_name[] = 0, const ASYS_TCHAR service_description[] = 0, int use_select = 1 ); int open ( const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor * = ACE_Reactor::instance (), ACE_Creation_Strategy * = 0, ACE_Accept_Strategy * = 0, ACE_Concurrency_Strategy * = 0, ACE_Scheduling_Strategy * = 0, const ASYS_TCHAR *service_name = 0, const ASYS_TCHAR *service_description = 0, int use_select = 1 ); virtual ~ACE_Strategy_Acceptor (void); virtual operator ACE_PEER_ACCEPTOR &() const; virtual ACE_PEER_ACCEPTOR &acceptor (void) const; virtual ACE_HANDLE get_handle (void) const; void dump (void) const; ACE_ALLOC_HOOK_DECLARE; protected: virtual int suspend (void); virtual int resume (void); virtual int fini (void); virtual int info (ASYS_TCHAR **buf, size_t) const; virtual int make_svc_handler (SVC_HANDLER *&); virtual int accept_svc_handler (SVC_HANDLER *svc_handler); virtual int activate_svc_handler (SVC_HANDLER *svc_handler); virtual int handle_close ( ACE_HANDLE = ACE_INVALID_HANDLE, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK ); virtual int handle_signal (int signum, siginfo_t *, ucontext_t *); typedef ACE_Creation_Strategy CREATION_STRATEGY; typedef ACE_Accept_Strategy ACCEPT_STRATEGY; typedef ACE_Concurrency_Strategy CONCURRENCY_STRATEGY; typedef ACE_Scheduling_Strategy SCHEDULING_STRATEGY; CREATION_STRATEGY *creation_strategy_; int delete_creation_strategy_; ACCEPT_STRATEGY *accept_strategy_; int delete_accept_strategy_; CONCURRENCY_STRATEGY *concurrency_strategy_; int delete_concurrency_strategy_; SCHEDULING_STRATEGY *scheduling_strategy_; int delete_scheduling_strategy_; ASYS_TCHAR *service_name_; ASYS_TCHAR *service_description_; u_short service_port_; ACE_PEER_ACCEPTOR_ADDR service_addr_; }; ``` ## DESCRIPTION Implements a flexible and extensible set of strategies for passively establishing connections with clients. There are three main strategies: (1) creating a SVC\_HANDLER, (2) passively accepting a new connection from a client into the SVC\_HANDLER, and (3) activating the SVC\_HANDLER with a particular concurrency mechanism. ## Initialization and termination methods. ``` ACE_Strategy_Acceptor ( const ASYS_TCHAR service_name[] = 0, const ASYS_TCHAR service_description[] = 0, int use_select = 1 ); ``` Default constructor. ``` ACE_Strategy_Acceptor ( const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor * = ACE_Reactor::instance (), ACE_Creation_Strategy * = 0, ACE_Accept_Strategy * = 0, ACE_Concurrency_Strategy * = 0, ACE_Scheduling_Strategy * = 0, const ASYS_TCHAR service_name[] = 0, const ASYS_TCHAR service_description[] = 0, int use_select = 1 ); ``` Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register this with the Reactor and listen for connection requests at the designated local\_addr. ``` int open ( const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor * = ACE_Reactor::instance (), ACE_Creation_Strategy * = 0, ACE_Accept_Strategy * = 0, ACE_Concurrency_Strategy * = 0, ACE_Scheduling_Strategy * = 0, const ASYS_TCHAR *service_name = 0, const ASYS_TCHAR *service_description = 0, int use_select = 1 ); ``` Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register this with the Reactor and listen for connection requests at the designated local\_addr. ``` virtual ~ACE_Strategy_Acceptor (void); ``` Close down the Strategy\_Acceptor's resources. ``` virtual operator ACE_PEER_ACCEPTOR &() const; ``` Return the underlying PEER\_ACCEPTOR object. ``` virtual ACE_PEER_ACCEPTOR &acceptor (void) const; ``` Return the underlying PEER\_ACCEPTOR object. ``` virtual ACE_HANDLE get_handle (void) const; ``` Returns the listening acceptor's ACE\_HANDLE. ``` void dump (void) const; ``` Dump the state of an object. ``` ACE_ALLOC_HOOK_DECLARE; ``` Declare the dynamic allocation hooks. ## Service management hooks. ``` virtual int suspend (void); ``` This method delegates to the Scheduling\_Strategy's suspend method. ``` virtual int resume (void); ``` This method delegates to the Scheduling\_Strategy's resume method. ``` virtual int fini (void); ``` Calls handle\_close when dynamically unlinked. ``` virtual int info (ASYS_TCHAR **buf, size_t) const; ``` Default version returns address info in buf. \= The following three methods define the Acceptor's strategies for creating, accepting, and activating SVC\_HANDLER's, respectively. ``` virtual int make_svc_handler (SVC_HANDLER *&); ``` Bridge method for creating a SVC\_HANDLER. The strategy for creating a SVC\_HANDLER are configured into the Acceptor via it's creation\_strategy\_. The default is to create a new SVC\_HANDLER if sh == 0, else sh is unchanged. However, subclasses can override this policy 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.). Returns -1 on failure, else 0. ``` virtual int accept_svc_handler (SVC_HANDLER *svc_handler); ``` Bridge method for accepting the new connection into the SVC\_HANDLER. The default behavior delegates to the PEER\_ACCEPTOR::accept in the Acceptor\_Strategy. ``` virtual int activate_svc_handler (SVC_HANDLER *svc_handler); ``` Bridge method for activating a SVC\_HANDLER with the appropriate concurrency strategy. The default behavior of this method is to activate the SVC\_HANDLER by calling its open method (which allows the SVC\_HANDLER to define its own concurrency strategy). However, subclasses can override this strategy to do more sophisticated concurrency activations (such as creating the SVC\_HANDLER as an "active object" via multi-threading or multi-processing). ## Demultiplexing hooks. ``` virtual int handle_close ( ACE_HANDLE = ACE_INVALID_HANDLE, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK ); ``` Perform termination activities when this is removed from the Reactor. ``` virtual int handle_signal (int signum, siginfo_t *, ucontext_t *); ``` Handle SIGINT. ## These data members are logically private" but are put in the" protected part in case subclasses want to access them. ## Define some useful typedefs. ``` typedef ACE_Creation_Strategy CREATION_STRATEGY; ``` ``` typedef ACE_Accept_Strategy ACCEPT_STRATEGY; ``` ``` typedef ACE_Concurrency_Strategy CONCURRENCY_STRATEGY; ``` ``` typedef ACE_Scheduling_Strategy SCHEDULING_STRATEGY; ``` ## Strategy objects. ``` CREATION_STRATEGY *creation_strategy_; ``` Creation strategy for an Acceptor. ``` int delete_creation_strategy_; ``` 1 if Acceptor created the creation strategy and thus should delete it, else 0. ``` ACCEPT_STRATEGY *accept_strategy_; ``` Accept strategy for an Acceptor. ``` int delete_accept_strategy_; ``` 1 if Acceptor created the accept strategy and thus should delete it, else 0. ``` CONCURRENCY_STRATEGY *concurrency_strategy_; ``` Concurrency strategy for an Acceptor. ``` int delete_concurrency_strategy_; ``` 1 if Acceptor created the concurrency strategy and thus should delete it, else 0. ``` SCHEDULING_STRATEGY *scheduling_strategy_; ``` Scheduling strategy for an Acceptor. ``` int delete_scheduling_strategy_; ``` 1 if Acceptor created the scheduling strategy and thus should delete it, else 0. ## Service information objects. ``` ASYS_TCHAR *service_name_; ``` Name of the service. ``` ASYS_TCHAR *service_description_; ``` Description of the service. ``` u_short service_port_; ``` Port number for the server. ``` ACE_PEER_ACCEPTOR_ADDR service_addr_; ``` Address that the Strategy\_Acceptor uses to listen for connections. ## AUTHOR Doug Schmidt ## LIBRARY ace