ACE_Oneshot_Acceptor< SVC_HANDLER, > Class Template Reference

Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER). More...

#include <Acceptor.h>

Inheritance diagram for ACE_Oneshot_Acceptor< SVC_HANDLER, >:

[legend]

Collaboration diagram for ACE_Oneshot_Acceptor< SVC_HANDLER, >:

[legend]

List of all members.


Public Types
typedef ACE_PEER_ACCEPTOR_ADDR	addr_type
typedef ACE_PEER_ACCEPTOR	acceptor_type
typedef SVC_HANDLER	handler_type
typedef SVC_HANDLER::stream_type	stream_type
Public Member Functions
	ACE_Oneshot_Acceptor (void)
	Constructor.
	ACE_Oneshot_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor reactor=ACE_Reactor::instance(), ACE_Concurrency_Strategy< SVC_HANDLER > =0)
int	open (const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor reactor=ACE_Reactor::instance(), ACE_Concurrency_Strategy< SVC_HANDLER > =0)
virtual	~ACE_Oneshot_Acceptor (void)
	Close down the {Oneshot_Acceptor}.
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)
	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.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
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
	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)
virtual int	handle_input (ACE_HANDLE)
virtual int	handle_timeout (const ACE_Time_Value &tv, const void *arg)
	Called when an acceptor times out...
virtual int	init (int argc, ACE_TCHAR *argv[])
virtual int	fini (void)
virtual int	info (ACE_TCHAR **, size_t) const
	Default version returns address info in {buf}.
virtual int	suspend (void)
virtual int	resume (void)
Private Member Functions
int	register_handler (SVC_HANDLER *svc_handler, const ACE_Synch_Options &options, int restart)
Private Attributes
SVC_HANDLER *	svc_handler_
	Hold the svc_handler_ across asynchrony boundaries.
int	restart_
	Hold the restart flag across asynchrony boundaries.
ACE_PEER_ACCEPTOR	peer_acceptor_
	Factory that establishes connections passively.
ACE_Concurrency_Strategy < SVC_HANDLER > *	concurrency_strategy_
	Concurrency strategy for an Acceptor.
bool	delete_concurrency_strategy_

Detailed Description

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
class ACE_Oneshot_Acceptor< SVC_HANDLER, >

Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER).

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).