Generic factory for passively connecting clients and creating exactly one service handler of the type SVC_HANDLER specified in the template. More...

#include <Acceptor.h>

Inheritance diagram for ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >:

[legend]

Collaboration diagram for ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >:

[legend]

Public Types
typedef PEER_ACCEPTOR::PEER_ADDR	addr_type

typedef PEER_ACCEPTOR	acceptor_type

typedef SVC_HANDLER	handler_type

typedef SVC_HANDLER::stream_type	stream_type

Public Types inherited from ACE_Event_Handler
enum	{ LO_PRIORITY = 0 , HI_PRIORITY = 10 , NULL_MASK = 0 , READ_MASK = (1 << 0) , WRITE_MASK = (1 << 1) , EXCEPT_MASK = (1 << 2) , ACCEPT_MASK = (1 << 3) , CONNECT_MASK = (1 << 4) , TIMER_MASK = (1 << 5) , QOS_MASK = (1 << 6) , GROUP_QOS_MASK = (1 << 7) , SIGNAL_MASK = (1 << 8) , ALL_EVENTS_MASK , RWE_MASK , DONT_CALL = (1 << 9) }

enum	{ ACE_EVENT_HANDLER_NOT_RESUMED = -1 , ACE_REACTOR_RESUMES_HANDLER = 0 , ACE_APPLICATION_RESUMES_HANDLER }

typedef long	Reference_Count
	Reference count type.

Public Member Functions
	ACE_Oneshot_Acceptor ()
	Constructor.

	ACE_Oneshot_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor reactor=ACE_Reactor::instance(), ACE_Concurrency_Strategy< SVC_HANDLER > =0)

int	open (const typename PEER_ACCEPTOR::PEER_ADDR &, ACE_Reactor reactor=ACE_Reactor::instance(), ACE_Concurrency_Strategy< SVC_HANDLER > =0)

virtual	~ACE_Oneshot_Acceptor ()
	Close down the {Oneshot_Acceptor}.

virtual int	accept (SVC_HANDLER =0, typename PEER_ACCEPTOR::PEER_ADDR remote_addr=0, const ACE_Synch_Options &synch_options=ACE_Synch_Options::defaults, bool restart=true, bool reset_new_handle=false)

virtual int	cancel ()
	Cancel a oneshot acceptor that was started asynchronously.

virtual	operator PEER_ACCEPTOR & () const
	Return the underlying {PEER_ACCEPTOR} object.

virtual PEER_ACCEPTOR &	acceptor () const
	Return the underlying {PEER_ACCEPTOR} object.

virtual int	close ()
	Close down the {Oneshot_Acceptor}.

void	dump () const
	Dump the state of an object.

Public Member Functions inherited from ACE_Service_Object
	ACE_Service_Object (ACE_Reactor *=0)
	Constructor.

virtual	~ACE_Service_Object ()
	Destructor.

Public Member Functions inherited from ACE_Event_Handler
virtual	~ACE_Event_Handler ()=default
	Destructor is virtual to enable proper cleanup.

virtual void	set_handle (ACE_HANDLE)
	Set the I/O handle.

virtual int	priority () const

virtual void	priority (int priority)
	Set the priority of the Event_Handler.

virtual int	handle_output (ACE_HANDLE fd=ACE_INVALID_HANDLE)

virtual int	handle_exception (ACE_HANDLE fd=ACE_INVALID_HANDLE)
	Called when an exceptional events occur (e.g., SIGURG).

virtual int	handle_exit (ACE_Process *)
	Called when a process exits.

virtual int	handle_signal (int signum, siginfo_t =0, ucontext_t =0)

virtual int	resume_handler ()

virtual int	handle_qos (ACE_HANDLE=ACE_INVALID_HANDLE)

virtual int	handle_group_qos (ACE_HANDLE=ACE_INVALID_HANDLE)

virtual void	reactor (ACE_Reactor *reactor)
	Set the event demultiplexors.

virtual ACE_Reactor *	reactor () const
	Get the event demultiplexors.

virtual ACE_Reactor_Timer_Interface *	reactor_timer_interface () const
	Get only the reactor's timer related interface.

virtual Reference_Count	add_reference ()
	Increment reference count on the handler.

virtual Reference_Count	remove_reference ()
	Decrement reference count on the handler.

Reference_Counting_Policy &	reference_counting_policy ()
	Current Reference_Counting_Policy.

Public Member Functions inherited from ACE_Shared_Object
	ACE_Shared_Object ()
	Constructor.

virtual	~ACE_Shared_Object ()
	Destructor.

Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.

Public Attributes inherited from ACE_Service_Object
	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, typename PEER_ACCEPTOR::PEER_ADDR remote_addr, ACE_Time_Value *timeout, bool restart, bool reset_new_handle)

virtual ACE_HANDLE	get_handle () 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 ()

virtual int	info (ACE_TCHAR **, size_t) const
	Default version returns address info in {buf}.

virtual int	suspend ()

virtual int	resume ()

Protected Member Functions inherited from ACE_Event_Handler
	ACE_Event_Handler (ACE_Reactor *=nullptr, int priority=ACE_Event_Handler::LO_PRIORITY)
	Force ACE_Event_Handler to be an abstract base class.

Private Member Functions
int	register_handler (SVC_HANDLER *svc_handler, const ACE_Synch_Options &options, bool restart)

Private Attributes
SVC_HANDLER *	svc_handler_
	Hold the svc_handler_ across asynchrony boundaries.

bool	restart_
	Hold the restart flag across asynchrony boundaries.

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_

Additional Inherited Members
Static Public Member Functions inherited from ACE_Event_Handler
static ACE_THR_FUNC_RETURN	read_adapter (void *event_handler)

static int	register_stdin_handler (ACE_Event_Handler eh, ACE_Reactor reactor, ACE_Thread_Manager *thr_mgr, int flags=THR_DETACHED)

static int	remove_stdin_handler (ACE_Reactor reactor, ACE_Thread_Manager thr_mgr)
	Performs the inverse of the register_stdin_handler() method.

Protected Types inherited from ACE_Event_Handler
typedef std::atomic< Reference_Count >	Atomic_Reference_Count
	Typedef for implementation of reference counting.

Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_
	Reference count.

Detailed Description

template<typename SVC_HANDLER, typename PEER_ACCEPTOR>
class ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >

Generic factory for passively connecting clients and creating exactly one service handler of the type SVC_HANDLER specified in the template.

This class works similarly to the regular ACE_Acceptor, but with the following differences:

ACE_Oneshot_Acceptor doesn't automatically register itself with the ACE_Reactor; the caller is expected to call the accept() method directly. Since a later call to accept() may require a reactor, the constructor and open() methods both accept an ACE_Reactor pointer which is saved in case it's needed in accept().
ACE_Oneshot_Acceptor doesn't need an ACE_Creation_Strategy (because the user supplies the SVC_HANDLER) or an ACE_Accept_Strategy (because this class only accepts one connection and then removes all traces of itself from the ACE_Reactor if it was registered for asynchronous accepts).

The usage model for ACE_Oneshot_Acceptor is:

Instantiate an object and establish its local address to listen at. This can be accomplished using either the address-accepting constructor (but there's no error indication) or the default constructor followed by a call to open().
Call the accept() method. This will attempt to accept a connection immediately. If there is no immediately available connection to accept, behavior is governed by the ACE_Synch_Options argument passed to open().

Member Typedef Documentation

◆ acceptor_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef PEER_ACCEPTOR ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::acceptor_type

◆ addr_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef PEER_ACCEPTOR::PEER_ADDR ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::addr_type

◆ handler_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef SVC_HANDLER ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::handler_type

◆ stream_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef SVC_HANDLER::stream_type ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::stream_type

Constructor & Destructor Documentation

◆ ACE_Oneshot_Acceptor() [1/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::ACE_Oneshot_Acceptor ( )

Constructor.

◆ ACE_Oneshot_Acceptor() [2/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::ACE_Oneshot_Acceptor	(	const typename PEER_ACCEPTOR::PEER_ADDR &	local_addr,
		ACE_Reactor *	reactor = ACE_Reactor::instance (),
		ACE_Concurrency_Strategy< SVC_HANDLER > *	cs = 0 )

Initialize the appropriate strategies for concurrency and then open the acceptor at the designated local_addr. Note that unlike ACE_Acceptor and ACE_Strategy_Acceptor, this method does NOT register this acceptor with the reactor at this point – the reactor parameter is saved in case it's needed later.

◆ ~ACE_Oneshot_Acceptor()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::~ACE_Oneshot_Acceptor ( )

virtual

Close down the {Oneshot_Acceptor}.

Member Function Documentation

◆ accept()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::accept	(	SVC_HANDLER *	svc_handler = 0,
		typename PEER_ACCEPTOR::PEER_ADDR *	remote_addr = 0,
		const ACE_Synch_Options &	synch_options = ACE_Synch_Options::defaults,
		bool	restart = true,
		bool	reset_new_handle = false )

virtual

Create a {SVC_HANDLER}, accept the connection into the {SVC_HANDLER}, and activate the {SVC_HANDLER}.

◆ acceptor()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

PEER_ACCEPTOR & ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::acceptor ( ) const

virtual

Return the underlying {PEER_ACCEPTOR} object.

◆ activate_svc_handler()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::activate_svc_handler ( SVC_HANDLER * svc_handler )

protectedvirtual

Bridge method for activating a {svc_handler} with the appropriate concurrency strategy. Default behavior is to activate the {SVC_HANDLER} as a "passive object." 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).

◆ cancel()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::cancel ( )

virtual

Cancel a oneshot acceptor that was started asynchronously.

◆ close()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::close ( )

virtual

Close down the {Oneshot_Acceptor}.

◆ dump()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

PEER_ACCEPTOR void ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::dump ( ) const

Dump the state of an object.

◆ fini()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::fini ( )

protectedvirtual

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

Reimplemented from ACE_Shared_Object.

◆ get_handle()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_HANDLE ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::get_handle ( ) const

protectedvirtual

Returns the listening acceptor's {ACE_HANDLE}.

Reimplemented from ACE_Event_Handler.

◆ handle_close()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::handle_close	(	ACE_HANDLE	= ACE_INVALID_HANDLE,
		ACE_Reactor_Mask	= ACE_Event_Handler::ALL_EVENTS_MASK )

protectedvirtual

Perform termination activities when {this} is removed from the {reactor}.

Reimplemented from ACE_Event_Handler.

◆ handle_input()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::handle_input ( ACE_HANDLE )

protectedvirtual

Accept one connection from a client and activates the SVC_HANDLER.

Reimplemented from ACE_Event_Handler.

◆ handle_timeout()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::handle_timeout	(	const ACE_Time_Value &	tv,
		const void *	arg )

protectedvirtual

Called when an acceptor times out...

Reimplemented from ACE_Event_Handler.

◆ info()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::info	(	ACE_TCHAR **	strp,
		size_t	length ) const

protectedvirtual

Default version returns address info in {buf}.

Reimplemented from ACE_Shared_Object.

◆ init()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::init	(	int	argc,
		ACE_TCHAR *	argv[] )

protectedvirtual

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

Reimplemented from ACE_Shared_Object.

◆ open()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::open	(	const typename PEER_ACCEPTOR::PEER_ADDR &	local_addr,
		ACE_Reactor *	reactor = ACE_Reactor::instance (),
		ACE_Concurrency_Strategy< SVC_HANDLER > *	con_s = 0 )

Initialize the appropriate strategies for concurrency and then open the acceptor at the designated local_addr. Note that unlike ACE_Acceptor and ACE_Strategy_Acceptor, this method does NOT register this acceptor with the reactor at this point – the reactor parameter is saved in case it's needed later.

◆ operator PEER_ACCEPTOR &()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::operator PEER_ACCEPTOR & ( ) const

virtual

Return the underlying {PEER_ACCEPTOR} object.

◆ register_handler()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::register_handler	(	SVC_HANDLER *	svc_handler,
		const ACE_Synch_Options &	options,
		bool	restart )

private

Insert ourselves into the {ACE_Reactor} so that we can continue accepting this connection asynchronously. This method should NOT be called by developers directly.

◆ resume()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::resume ( )

protectedvirtual

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

Reimplemented from ACE_Service_Object.

◆ shared_accept()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Oneshot_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::shared_accept	(	SVC_HANDLER *	svc_handler,
		typename PEER_ACCEPTOR::PEER_ADDR *	remote_addr,
		ACE_Time_Value *	timeout,
		bool	restart,
		bool	reset_new_handle )