--- name: "ACE_Oneshot_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_Oneshot_Acceptor" --- # ACE\_Oneshot\_Acceptor(3) Generic factory for passively connecting clients and creating exactly one service handler (SVC\_HANDLER). ## NAME ACE\_Oneshot\_Acceptor - Generic factory for passively connecting clients and creating exactly one service handler (SVC\_HANDLER). ## SYNOPSIS ``` #include template class ACE_Oneshot_Acceptor : public ACE_Service_Object { public: ACE_Oneshot_Acceptor (void); ACE_Oneshot_Acceptor ( const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor = ACE_Reactor::instance (), ACE_Concurrency_Strategy * = 0 ); int open ( const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor *reactor = ACE_Reactor::instance (), ACE_Concurrency_Strategy * = 0 ); virtual ~ACE_Oneshot_Acceptor (void); virtual int accept ( SVC_HANDLER * = 0, ACE_PEER_ACCEPTOR_ADDR *remote_addr = 0, const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults, int restart = 1, int reset_new_handle = 0 ); virtual int cancel (void); virtual operator ACE_PEER_ACCEPTOR &() const; virtual ACE_PEER_ACCEPTOR &acceptor (void) const; virtual int close (void); void dump (void) const; ACE_ALLOC_HOOK_DECLARE; protected: virtual int activate_svc_handler (SVC_HANDLER *svc_handler); int shared_accept ( SVC_HANDLER *svc_handler, ACE_PEER_ACCEPTOR_ADDR *remote_addr, ACE_Time_Value *timeout, int restart, int reset_new_handle ); virtual ACE_HANDLE get_handle (void) const; virtual int handle_close ( ACE_HANDLE = ACE_INVALID_HANDLE, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK ); virtual int handle_input (ACE_HANDLE); virtual int handle_timeout ( const ACE_Time_Value &tv, const void *arg ); virtual int init (int argc, ASYS_TCHAR *argv[]); virtual int fini (void); virtual int info (ASYS_TCHAR **, size_t) const; virtual int suspend (void); virtual int resume (void); private: int register_handler ( SVC_HANDLER *svc_handler, const ACE_Synch_Options &options, int restart ); SVC_HANDLER *svc_handler_; int restart_; ACE_PEER_ACCEPTOR peer_acceptor_; ACE_Concurrency_Strategy *concurrency_strategy_; int delete_concurrency_strategy_; }; ``` ## DESCRIPTION This class works similarly to the regular ACE\_Acceptor, with the following differences: 1\. This class doesn't automagically register this with the\ ACE\_Reactor since it expects to have its accept method\ called directly. However, it stashes the ACE\_Reactor\ pointer away in case it's needed later to finish accepting\ a connection asynchronously. 2\. The class doesn't need an ACE\_Creation\_Strategy (since\ the user supplies the SVC\_HANDLER) or an\ ACE\_Accept\_Strategy (since this class only accepts one\ connection and then removes all traces of itself from the\ ACE\_Reactor if it was registered for asynchronous\ accepts). ## Initialization and termination methods. ``` ACE_Oneshot_Acceptor (void); ``` Constructor. ``` ACE_Oneshot_Acceptor ( const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor = ACE_Reactor::instance (), ACE_Concurrency_Strategy * = 0 ); ``` Initialize the appropriate strategies for concurrency and then open the peer\_acceptor at the designated local\_addr. Note that unlike the ACE\_Acceptor and ACE\_Strategy\_Acceptor, this method does NOT register this acceptor with the reactor at this point -- it just stashes the reactor away in case it's needed later. ``` int open ( const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor *reactor = ACE_Reactor::instance (), ACE_Concurrency_Strategy * = 0 ); ``` Initialize the appropriate strategies for concurrency and then open the peer\_acceptor at the designated local\_addr. Note that unlike the ACE\_Acceptor and ACE\_Strategy\_Acceptor, this method does NOT register this acceptor with the reactor at this point -- it just stashes the reactor away in case it's needed later. ``` virtual ~ACE_Oneshot_Acceptor (void); ``` Close down the Oneshot\_Acceptor. ## Explicit factory operation. ``` virtual int accept ( SVC_HANDLER * = 0, ACE_PEER_ACCEPTOR_ADDR *remote_addr = 0, const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults, int restart = 1, int reset_new_handle = 0 ); ``` Create a SVC\_HANDLER, accept the connection into the SVC\_HANDLER, and activate the SVC\_HANDLER. ``` virtual int cancel (void); ``` Cancel a oneshot acceptor that was started asynchronously. ``` 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 int close (void); ``` Close down the Oneshot\_Acceptor. ``` void dump (void) const; ``` Dump the state of an object. ``` ACE_ALLOC_HOOK_DECLARE; ``` Declare the dynamic allocation hooks. ## Demultiplexing hooks. ``` virtual ACE_HANDLE get_handle (void) const; ``` Returns the listening acceptor's ACE\_HANDLE. ``` 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_input (ACE_HANDLE); ``` Accept one connection from a client and activates the SVC\_HANDLER. ``` virtual int handle_timeout ( const ACE_Time_Value &tv, const void *arg ); ``` Called when an acceptor times out... ## Dynamic linking hooks. ``` virtual int init (int argc, ASYS_TCHAR *argv[]); ``` Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. ``` virtual int fini (void); ``` Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. ``` virtual int info (ASYS_TCHAR **, size_t) const; ``` Default version returns address info in buf. ## Service management hooks. ``` virtual int suspend (void); ``` Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. ``` virtual int resume (void); ``` Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. ## AUTHOR Doug Schmidt ## LIBRARY ace