ACE_Asynch_Connector< HANDLER > Class Template Reference

This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections. More...

#include <Asynch_Connector.h>

Inheritance diagram for ACE_Asynch_Connector< HANDLER >:

Collaboration diagram for ACE_Asynch_Connector< HANDLER >:

Public Member Functions
	ACE_Asynch_Connector ()
	A do nothing constructor.
virtual	~ACE_Asynch_Connector ()=default
	Virtual destruction.
virtual int	open (bool pass_addresses=false, ACE_Proactor *proactor=0, bool validate_new_connection=true)
virtual int	connect (const ACE_INET_Addr &remote_sap, const ACE_INET_Addr &local_sap=(const ACE_INET_Addr &) ACE_Addr::sap_any, int reuse_addr=1, const void *act=0)
	This initiates a new asynchronous connect.
virtual int	cancel ()
virtual int	validate_connection (const ACE_Asynch_Connect::Result &result, const ACE_INET_Addr &remote, const ACE_INET_Addr &local)
virtual bool	pass_addresses () const
virtual void	pass_addresses (bool new_value)
virtual bool	validate_new_connection () const
virtual void	validate_new_connection (bool new_value)
Public Member Functions inherited from ACE_Handler
	ACE_Handler ()
	A do nothing constructor.
	ACE_Handler (ACE_Proactor *p)
	A do nothing constructor which allows proactor to be set to <p>.
virtual	~ACE_Handler ()
	Virtual destruction.
virtual void	handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
virtual void	handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result)
virtual void	handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result)
virtual void	handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
virtual void	handle_read_file (const ACE_Asynch_Read_File::Result &result)
virtual void	handle_write_file (const ACE_Asynch_Write_File::Result &result)
virtual void	handle_accept (const ACE_Asynch_Accept::Result &result)
	This method will be called when an asynchronous accept completes.
virtual void	handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result)
virtual void	handle_time_out (const ACE_Time_Value &tv, const void *act=0)
virtual void	handle_wakeup ()
ACE_Proactor *	proactor ()
	Get the proactor associated with this handler.
void	proactor (ACE_Proactor *p)
	Set the proactor.
virtual ACE_HANDLE	handle () const
virtual void	handle (ACE_HANDLE)
	Set the ACE_HANDLE value for this Handler.
Proxy_Ptr &	proxy ()

Protected Member Functions
virtual void	handle_connect (const ACE_Asynch_Connect::Result &result)
	This is called when an outstanding accept completes.
void	parse_address (const ACE_Asynch_Connect::Result &result, ACE_INET_Addr &remote_address, ACE_INET_Addr &local_address)
	This parses the address from read buffer.
ACE_Asynch_Connect &	asynch_connect ()
	Return the asynch Connect object.
virtual HANDLER *	make_handler ()

Private Attributes
ACE_Asynch_Connect	asynch_connect_
	Asynch_Connect used to make life easier :-)
bool	pass_addresses_
	Flag that indicates if parsing of addresses is necessary.
bool	validate_new_connection_
	Flag that indicates if address validation is required.

Additional Inherited Members
Public Types inherited from ACE_Handler
typedef ACE_Refcounted_Auto_Ptr< Proxy, ACE_SYNCH_MUTEX >	Proxy_Ptr
Protected Attributes inherited from ACE_Handler
ACE_Proactor *	proactor_
	The proactor associated with this handler.
ACE_HANDLE	handle_
	The ACE_HANDLE in use with this handler.
ACE_Refcounted_Auto_Ptr< Proxy, ACE_SYNCH_MUTEX >	proxy_
	Refers to proxy for this handler.

Detailed Description

template<class HANDLER>
class ACE_Asynch_Connector< HANDLER >

This class is an example of the Connector pattern. This class will establish new connections and create new HANDLER objects to handle the new connections.

Unlike the ACE_Connector, however, this class is designed to be used asynchronously with the ACE Proactor framework.

Constructor & Destructor Documentation

ACE_Asynch_Connector()

template<class HANDLER >

ACE_Asynch_Connector< HANDLER >::ACE_Asynch_Connector

(

)

A do nothing constructor.

~ACE_Asynch_Connector()

template<class HANDLER >

virtual ACE_Asynch_Connector< HANDLER >::~ACE_Asynch_Connector ( )

virtualdefault

Virtual destruction.

Member Function Documentation

asynch_connect()

template<class HANDLER >

ACE_Asynch_Connect & ACE_Asynch_Connector< HANDLER >::asynch_connect ( )

protected

Return the asynch Connect object.

cancel()

template<class HANDLER >

int ACE_Asynch_Connector< HANDLER >::cancel ( )

virtual

This cancels all pending accepts operations that were issued by the calling thread.

Note

On Windows, this method does not cancel connect operations issued by other threads.

On POSIX, delegates cancelation to ACE_POSIX_Asynch_Connect.

connect()

template<class HANDLER >

int ACE_Asynch_Connector< HANDLER >::connect ( const ACE_INET_Addr & remote_sap, const ACE_INET_Addr & local_sap = (const ACE_INET_Addr &)ACE_Addr::sap_any, int reuse_addr = 1, const void * act = 0 )

virtual

This initiates a new asynchronous connect.

handle_connect()

template<class HANDLER >

void ACE_Asynch_Connector< HANDLER >::handle_connect ( const ACE_Asynch_Connect::Result & result )

protectedvirtual

This is called when an outstanding accept completes.

Reimplemented from ACE_Handler.

make_handler()

template<class HANDLER >

HANDLER * ACE_Asynch_Connector< HANDLER >::make_handler ( )

protectedvirtual

This is the template method used to create new handler. Subclasses must overwrite this method if a new handler creation strategy is required.

open()

template<class HANDLER >

int ACE_Asynch_Connector< HANDLER >::open ( bool pass_addresses = false, ACE_Proactor * proactor = 0, bool validate_new_connection = true )

virtual

This opens asynch connector

parse_address()

template<class HANDLER >

void ACE_Asynch_Connector< HANDLER >::parse_address ( const ACE_Asynch_Connect::Result & result, ACE_INET_Addr & remote_address, ACE_INET_Addr & local_address )

protected

This parses the address from read buffer.

pass_addresses() [1/2]

template<class HANDLER >

bool ACE_Asynch_Connector< HANDLER >::pass_addresses ( ) const

virtual

Set and get flag that indicates if parsing and passing of addresses to the service_handler is necessary.

pass_addresses() [2/2]

template<class HANDLER >

void ACE_Asynch_Connector< HANDLER >::pass_addresses ( bool new_value )

virtual

validate_connection()

template<class HANDLER >

int ACE_Asynch_Connector< HANDLER >::validate_connection ( const ACE_Asynch_Connect::Result & result, const ACE_INET_Addr & remote, const ACE_INET_Addr & local )

virtual

Template method to validate peer before service is opened. This method is called when the connection attempt completes, whether it succeeded or failed, if the validate_connection argument to open() was non-zero or the validate_new_connection() method is called to turn this feature on. The default implementation returns 0. Users can (and probably should) reimplement this method to learn about the success or failure of the connection attempt. If the connection completed successfully, this method can be used to perform validation of the peer using it's address, running an authentication procedure (such as SSL) or anything else necessary or desireable. The return value from this method determines whether or not ACE will continue opening the service or abort the connection.

Parameters

result	Result of the connection acceptance. Use result.success() to determine success or failure of the connection attempt.
remote	Peer's address. If the connection failed, this object is undefined.
local	Local address connection was completed from. If the connection failed, this object is undefined.

Return values

-1	ACE_Asynch_Connector will close the connection, and the service will not be opened.
0	Service opening will proceeed.

Returns

Return value is ignored if the connection attempt failed.

validate_new_connection() [1/2]

template<class HANDLER >

bool ACE_Asynch_Connector< HANDLER >::validate_new_connection ( ) const

virtual

Set and get flag that indicates if address validation is required.

validate_new_connection() [2/2]

template<class HANDLER >

void ACE_Asynch_Connector< HANDLER >::validate_new_connection ( bool new_value )

virtual

Member Data Documentation

asynch_connect_

template<class HANDLER >

ACE_Asynch_Connect ACE_Asynch_Connector< HANDLER >::asynch_connect_

private

Asynch_Connect used to make life easier :-)

pass_addresses_

template<class HANDLER >

bool ACE_Asynch_Connector< HANDLER >::pass_addresses_

private

Flag that indicates if parsing of addresses is necessary.

validate_new_connection_

template<class HANDLER >

bool ACE_Asynch_Connector< HANDLER >::validate_new_connection_

private

Flag that indicates if address validation is required.

---

The documentation for this class was generated from the following files:

• Asynch_Connector.h
• Asynch_Connector.cpp