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

#include <Connector.h>

Inheritance diagram for ACE_Strategy_Connector:

[legend]

Collaboration diagram for ACE_Strategy_Connector:

[legend]

List of all members.

Public Types
typedef ACE_Creation_Strategy < SVC_HANDLER >	creation_strategy_type
typedef ACE_Connect_Strategy < SVC_HANDLER, ACE_PEER_CONNECTOR_2 >	connect_strategy_type
typedef ACE_Concurrency_Strategy < SVC_HANDLER >	concurrency_strategy_type
typedef ACE_Connector < SVC_HANDLER, ACE_PEER_CONNECTOR_2 >	base_type
typedef ACE_Creation_Strategy < SVC_HANDLER >	CREATION_STRATEGY
typedef ACE_Connect_Strategy < SVC_HANDLER, ACE_PEER_CONNECTOR_2 >	CONNECT_STRATEGY
typedef ACE_Concurrency_Strategy < SVC_HANDLER >	CONCURRENCY_STRATEGY
typedef ACE_Connector < SVC_HANDLER, ACE_PEER_CONNECTOR_2 >	SUPER
Public Member Functions
	ACE_Strategy_Connector (ACE_Reactor r=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > =0, ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > =0, ACE_Concurrency_Strategy< SVC_HANDLER > =0, int flags=0)
virtual int	open (ACE_Reactor *r, int flags)
virtual int	open (ACE_Reactor r=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > =0, ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > =0, ACE_Concurrency_Strategy< SVC_HANDLER > =0, int flags=0)
virtual	~ACE_Strategy_Connector (void)
	Shutdown a connector and release resources.
virtual int	close (void)
	Close down the Connector.
virtual ACE_Creation_Strategy < SVC_HANDLER > *	creation_strategy (void) const
virtual ACE_Connect_Strategy < SVC_HANDLER, ACE_PEER_CONNECTOR_2 > *	connect_strategy (void) const
virtual ACE_Concurrency_Strategy < SVC_HANDLER > *	concurrency_strategy (void) const
Protected Member Functions
virtual int	make_svc_handler (SVC_HANDLER *&sh)
virtual int	connect_svc_handler (SVC_HANDLER &sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms)
virtual int	connect_svc_handler (SVC_HANDLER &sh, SVC_HANDLER &sh_copy, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms)
virtual int	activate_svc_handler (SVC_HANDLER *svc_handler)
Protected Attributes
CREATION_STRATEGY *	creation_strategy_
	Creation strategy for an Connector.
bool	delete_creation_strategy_
CONNECT_STRATEGY *	connect_strategy_
	Connect strategy for a Connector.
bool	delete_connect_strategy_
CONCURRENCY_STRATEGY *	concurrency_strategy_
	Concurrency strategy for a Connector.
bool	delete_concurrency_strategy_

Detailed Description

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

Implements a flexible and extensible set of strategies for actively establishing connections with clients. There are three main strategies: (1) creating a SVC_HANDLER, (2) actively initiating a new connection from the client, and (3) activating the SVC_HANDLER with a particular concurrency mechanism after the connection is established.

Member Typedef Documentation

typedef ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector::base_type

typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Connector::CONCURRENCY_STRATEGY

typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Connector::concurrency_strategy_type

typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector::CONNECT_STRATEGY

typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector::connect_strategy_type

typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Connector::CREATION_STRATEGY

typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Connector::creation_strategy_type

typedef ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector::SUPER

Constructor & Destructor Documentation

ACE_Strategy_Connector::ACE_Strategy_Connector	(	ACE_Reactor *	r = `ACE_Reactor::instance ()`,
		ACE_Creation_Strategy< SVC_HANDLER > *	cre_s = `0`,
		ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > *	conn_s = `0`,
		ACE_Concurrency_Strategy< SVC_HANDLER > *	con_s = `0`,
		int	flags = `0`
	)

Initialize a connector. flags indicates how SVC_HANDLER's should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the SVC_HANDLER when it is opened.

ACE_Strategy_Connector::~ACE_Strategy_Connector ( void ) [virtual]

Shutdown a connector and release resources.

Member Function Documentation

int ACE_Strategy_Connector::activate_svc_handler ( SVC_HANDLER * svc_handler ) [protected, virtual]

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_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

int ACE_Strategy_Connector::close ( void ) [virtual]

Close down the Connector.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

ACE_Concurrency_Strategy< SVC_HANDLER > * ACE_Strategy_Connector::concurrency_strategy ( void ) const [virtual]

ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > * ACE_Strategy_Connector::connect_strategy ( void ) const [virtual]

int ACE_Strategy_Connector::connect_svc_handler	(	SVC_HANDLER *&	sh,
		const ACE_PEER_CONNECTOR_ADDR &	remote_addr,
		ACE_Time_Value *	timeout,
		const ACE_PEER_CONNECTOR_ADDR &	local_addr,
		int	reuse_addr,
		int	flags,
		int	perms
	)		`[protected, virtual]`

Bridge method for connecting the new connection into the SVC_HANDLER. The default behavior delegates to the <PEER_CONNECTOR::connect> in the <Connect_Strategy>.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

int ACE_Strategy_Connector::connect_svc_handler	(	SVC_HANDLER *&	sh,
		SVC_HANDLER *&	sh_copy,
		const ACE_PEER_CONNECTOR_ADDR &	remote_addr,
		ACE_Time_Value *	timeout,
		const ACE_PEER_CONNECTOR_ADDR &	local_addr,
		int	reuse_addr,
		int	flags,
		int	perms
	)		`[protected, virtual]`

Bridge method for connecting the new connection into the SVC_HANDLER. The default behavior delegates to the <PEER_CONNECTOR::connect> in the <Connect_Strategy>. sh_copy is used to obtain a copy of the sh pointer, but that can be kept in the stack; the motivation is a bit too long to include here, but basically we want to modify sh safely, using the internal locks in the Connect_Strategy, while saving a TSS copy in sh_copy, usually located in the stack.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

ACE_Creation_Strategy< SVC_HANDLER > * ACE_Strategy_Connector::creation_strategy ( void ) const [virtual]

int ACE_Strategy_Connector::make_svc_handler ( SVC_HANDLER *& sh ) [protected, virtual]

Bridge method for creating a SVC_HANDLER. The strategy for creating a SVC_HANDLER are configured into the Connector via it's <creation_strategy_>. The default is to create a new SVC_HANDLER only 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 if failure, else 0.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

int ACE_Strategy_Connector::open	(	ACE_Reactor *	r,
		int	flags
	)		`[virtual]`

Initialize a connector. flags indicates how SVC_HANDLER's should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the SVC_HANDLER when it is opened. Default strategies would be created and used.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

int ACE_Strategy_Connector::open	(	ACE_Reactor *	r = `ACE_Reactor::instance ()`,
		ACE_Creation_Strategy< SVC_HANDLER > *	cre_s = `0`,
		ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > *	conn_s = `0`,
		ACE_Concurrency_Strategy< SVC_HANDLER > *	con_s = `0`,
		int	flags = `0`
	)		`[virtual]`

Initialize a connector. flags indicates how SVC_HANDLER's should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the SVC_HANDLER when it is opened.