Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER. More...

#include <Acceptor.h>

Inheritance diagram for ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >:

[legend]

Collaboration diagram for ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >:

[legend]

Public Types
typedef ACE_Creation_Strategy< SVC_HANDLER >	creation_strategy_type

typedef ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR >	accept_strategy_type

typedef ACE_Concurrency_Strategy< SVC_HANDLER >	concurrency_strategy_type

typedef ACE_Scheduling_Strategy< SVC_HANDLER >	scheduling_strategy_type

typedef ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >	base_type

typedef ACE_Creation_Strategy< SVC_HANDLER >	CREATION_STRATEGY

typedef ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR >	ACCEPT_STRATEGY

typedef ACE_Concurrency_Strategy< SVC_HANDLER >	CONCURRENCY_STRATEGY

typedef ACE_Scheduling_Strategy< SVC_HANDLER >	SCHEDULING_STRATEGY

Public Types inherited from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
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_Strategy_Acceptor (const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT, int reuse_addr=1)
	Default constructor.

	ACE_Strategy_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor =ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > =0, ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > =0, ACE_Concurrency_Strategy< SVC_HANDLER > =0, ACE_Scheduling_Strategy< SVC_HANDLER > *=0, const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT, int reuse_addr=1)

virtual int	open (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor *reactor, int flags=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT, int reuse_addr=1)

virtual int	open (const typename PEER_ACCEPTOR::PEER_ADDR &, ACE_Reactor =ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > =0, ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > =0, ACE_Concurrency_Strategy< SVC_HANDLER > =0, ACE_Scheduling_Strategy< SVC_HANDLER > =0, const ACE_TCHAR service_name=0, const ACE_TCHAR *service_description=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT, int reuse_addr=1)

virtual	~ACE_Strategy_Acceptor ()
	Close down the Strategy_Acceptor's resources.

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

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

virtual ACE_HANDLE	get_handle () const
	Returns the listening acceptor's {ACE_HANDLE}.

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

virtual int	suspend ()

virtual int	resume ()

Public Member Functions inherited from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
	ACE_Acceptor (ACE_Reactor *=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT)
	"Do-nothing" constructor.

	ACE_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor *reactor=ACE_Reactor::instance(), int flags=0, int use_select=ACE_DEFAULT_ACCEPTOR_USE_SELECT, int reuse_addr=1)

virtual	~ACE_Acceptor ()
	Close down the Acceptor's resources.

virtual int	close ()
	Close down the Acceptor.

virtual int	handle_accept_error ()

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_timeout (const ACE_Time_Value &current_time, const void *act=0)

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

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_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
	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	fini ()
	Calls {handle_close} when dynamically unlinked.

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

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

Protected Member Functions inherited from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
virtual int	handle_input (ACE_HANDLE)

virtual int	init (int argc, ACE_TCHAR *argv[])

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.

Protected Attributes
CREATION_STRATEGY *	creation_strategy_
	Creation strategy for an Acceptor.

bool	delete_creation_strategy_

ACCEPT_STRATEGY *	accept_strategy_
	Accept strategy for an {Acceptor}.

bool	delete_accept_strategy_

CONCURRENCY_STRATEGY *	concurrency_strategy_
	Concurrency strategy for an {Acceptor}.

bool	delete_concurrency_strategy_

SCHEDULING_STRATEGY *	scheduling_strategy_
	Scheduling strategy for an {Acceptor}.

bool	delete_scheduling_strategy_

ACE_TCHAR *	service_name_
	Name of the service.

ACE_TCHAR *	service_description_
	Description of the service.

PEER_ACCEPTOR::PEER_ADDR	service_addr_

Protected Attributes inherited from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
PEER_ACCEPTOR	peer_acceptor_
	Concrete factory for accepting connections from clients...

PEER_ACCEPTOR::PEER_ADDR	peer_acceptor_addr_
	Needed to reopen the socket if {accept} fails.

int	flags_

int	use_select_

int	reuse_addr_
	Needed to reopen the socket if {accept} fails.

Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_
	Reference count.

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.

Detailed Description

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

Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.

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.

Member Typedef Documentation

◆ ACCEPT_STRATEGY

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::ACCEPT_STRATEGY

◆ accept_strategy_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::accept_strategy_type

◆ base_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::base_type

◆ CONCURRENCY_STRATEGY

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::CONCURRENCY_STRATEGY

◆ concurrency_strategy_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::concurrency_strategy_type

◆ CREATION_STRATEGY

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::CREATION_STRATEGY

◆ creation_strategy_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::creation_strategy_type

◆ SCHEDULING_STRATEGY

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::SCHEDULING_STRATEGY

◆ scheduling_strategy_type

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::scheduling_strategy_type

Constructor & Destructor Documentation

◆ ACE_Strategy_Acceptor() [1/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::ACE_Strategy_Acceptor	(	const ACE_TCHAR	service_name[] = 0,
		const ACE_TCHAR	service_description[] = 0,
		int	use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT,
		int	reuse_addr = 1 )

Default constructor.

◆ ACE_Strategy_Acceptor() [2/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::ACE_Strategy_Acceptor	(	const typename PEER_ACCEPTOR::PEER_ADDR &	local_addr,
		ACE_Reactor *	reactor = ACE_Reactor::instance (),
		ACE_Creation_Strategy< SVC_HANDLER > *	cre_s = 0,
		ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > *	acc_s = 0,
		ACE_Concurrency_Strategy< SVC_HANDLER > *	con_s = 0,
		ACE_Scheduling_Strategy< SVC_HANDLER > *	sch_s = 0,
		const ACE_TCHAR	service_name[] = 0,
		const ACE_TCHAR	service_description[] = 0,
		int	use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT,
		int	reuse_addr = 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}.

◆ ~ACE_Strategy_Acceptor()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

virtual

Close down the Strategy_Acceptor's resources.

Member Function Documentation

◆ accept_svc_handler()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::accept_svc_handler ( SVC_HANDLER * svc_handler )

protectedvirtual

Bridge method for accepting the new connection into the {SVC_HANDLER}. The default behavior delegates to the {PEER_ACCEPTOR::accept} in the {Acceptor_Strategy}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ acceptor()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

virtual

Return the underlying PEER_ACCEPTOR object.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ activate_svc_handler()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ dump()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

Dump the state of an object.

◆ fini()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

protectedvirtual

Calls {handle_close} when dynamically unlinked.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ get_handle()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

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

virtual

Returns the listening acceptor's {ACE_HANDLE}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ handle_close()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_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_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ handle_signal()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::handle_signal	(	int	signum,
		siginfo_t *	,
		ucontext_t *	)

protectedvirtual

Handle SIGINT.

Reimplemented from ACE_Event_Handler.

◆ info()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::info	(	ACE_TCHAR **	buf,
		size_t	length ) const

protectedvirtual

Default version returns address info in {buf}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ make_svc_handler()

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::make_svc_handler ( SVC_HANDLER *& sh )

protectedvirtual

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.

Reimplemented from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >.

◆ open() [1/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::open	(	const typename PEER_ACCEPTOR::PEER_ADDR &	local_addr,
		ACE_Reactor *	reactor = ACE_Reactor::instance (),
		ACE_Creation_Strategy< SVC_HANDLER > *	cre_s = 0,
		ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > *	acc_s = 0,
		ACE_Concurrency_Strategy< SVC_HANDLER > *	con_s = 0,
		ACE_Scheduling_Strategy< SVC_HANDLER > *	sch_s = 0,
		const ACE_TCHAR *	service_name = 0,
		const ACE_TCHAR *	service_description = 0,
		int	use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT,
		int	reuse_addr = 1 )

virtual

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

◆ open() [2/2]

template<typename SVC_HANDLER , typename PEER_ACCEPTOR >

int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::open	(	const typename PEER_ACCEPTOR::PEER_ADDR &	local_addr,
		ACE_Reactor *	reactor,
		int	flags = 0,
		int	use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT,
		int	reuse_addr = 1 )

virtual

Open the contained PEER_ACCEPTOR object to begin listening, and register with the specified reactor for accept events.

The PEER_ACCEPTOR handle is put into non-blocking mode as a safeguard against the race condition that can otherwise occur between the time when the passive-mode socket handle is "ready" and when the actual accept call is made. During this interval, the client can shutdown the connection, in which case, the {accept} call can hang.

Parameters

local_addr	The address to listen at.
reactor	Pointer to the ACE_Reactor instance to register this object with. The default is the singleton.
flags	Flags to control what mode an accepted socket will be put into after it is accepted. The only legal value for this argument is `ACE_NONBLOCK`, which enables non-blocking mode on the accepted peer stream object in `SVC_HANDLER`. The default is 0.
use_select	Affects behavior when called back by the reactor when a connection can be accepted. If non-zero, this object will accept all pending connections, instead of just the one that triggered the reactor callback. Uses ACE_OS::select() internally to detect any remaining acceptable connections. The default is 1.
reuse_addr	Passed to the `PEER_ACCEPTOR::open()` method with `local_addr`. Generally used to request that the OS allow reuse of the listen port. The default is 1.