ACE_Asynch_Accept Class Reference

This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class. More...

#include <Asynch_IO.h>

Inheritance diagram for ACE_Asynch_Accept:

Collaboration diagram for ACE_Asynch_Accept:

Classes
class	Result
	This is that class which will be passed back to the {handler} when the asynchronous accept completes. More...

Public Member Functions
	ACE_Asynch_Accept (void)
	A do nothing constructor. More...
virtual	~ACE_Asynch_Accept (void)
	Destructor. More...
int	open (ACE_Handler &handler, ACE_HANDLE handle=ACE_INVALID_HANDLE, const void *completion_key=0, ACE_Proactor *proactor=0)
int	accept (ACE_Message_Block &message_block, size_t bytes_to_read, ACE_HANDLE accept_handle=ACE_INVALID_HANDLE, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN, int addr_family=AF_INET)
virtual ACE_Asynch_Operation_Impl *	implementation (void) const
	Return the underlying implementation class. More...
Public Member Functions inherited from ACE_Asynch_Operation
int	open (ACE_Handler &handler, ACE_HANDLE handle, const void *completion_key, ACE_Proactor *proactor)
int	cancel (void)
ACE_Proactor *	proactor (void) const
	Return the underlying proactor. More...
virtual	~ACE_Asynch_Operation (void)
	Destructor. More...

Protected Attributes
ACE_Asynch_Accept_Impl *	implementation_

Private Member Functions
void	operator= (const ACE_Asynch_Accept &)
	ACE_Asynch_Accept (const ACE_Asynch_Accept &)

Additional Inherited Members
Protected Member Functions inherited from ACE_Asynch_Operation
	ACE_Asynch_Operation (void)
	Constructor. More...
ACE_Proactor *	get_proactor (ACE_Proactor *user_proactor, ACE_Handler &handler) const
	Get a proactor for/from the user. More...

Detailed Description

This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class.

Once {open} is called, multiple asynchronous {accept}s can started using this class. A ACE_Asynch_Accept::Result will be passed back to the {handler} when the asynchronous accept completes through the {ACE_Handler::handle_accept} callback.

Constructor & Destructor Documentation

ACE_Asynch_Accept::ACE_Asynch_Accept

(

void

)

A do nothing constructor.

ACE_Asynch_Accept::~ACE_Asynch_Accept ( void  )

virtual

Destructor.

ACE_Asynch_Accept::ACE_Asynch_Accept ( const ACE_Asynch_Accept &  )

private

Member Function Documentation

int ACE_Asynch_Accept::accept	(	ACE_Message_Block &	message_block,
		size_t	bytes_to_read,
		ACE_HANDLE	accept_handle = ACE_INVALID_HANDLE,
		const void *	act = 0,
		int	priority = 0,
		int	signal_number = ACE_SIGRTMIN,
		int	addr_family = AF_INET
	)

This starts off an asynchronous accept. The asynchronous accept call also allows any initial data to be returned to the handler specified to open().

Parameters

message_block	A message block to receive initial data, as well as the local and remote addresses when the connection is made. Since the block receives the addresses regardless of whether or not initial data is available or requested, the message block size must be at least bytes_to_read plus two times the size of the addresses used (IPv4 or IPv6).
bytes_to_read	The maximum number of bytes of initial data to read into message_block.
accept_handle	The handle that the new connection will be accepted on. If INVALID_HANDLE, a new handle will be created using addr_family.
act	Value to be passed in result when operation completes.
priority	Priority of the operation. On POSIX4-Unix, this is supported. Works like nice in Unix. Negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than process. And so forth. On Win32, this argument is ignored.
signal_number	The POSIX4 real-time signal number to be used for the operation. Value range is from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is ignored on non-POSIX4 systems.
addr_family	The address family to use if accept_handle is ACE_INVALID_HANDLE and a new handle must be opened. Values are AF_INET and PF_INET6.

ACE_Asynch_Operation_Impl * ACE_Asynch_Accept::implementation ( void  ) const

virtual

Return the underlying implementation class.

Implements ACE_Asynch_Operation.

int ACE_Asynch_Accept::open	(	ACE_Handler &	handler,
		ACE_HANDLE	handle = ACE_INVALID_HANDLE,
		const void *	completion_key = 0,
		ACE_Proactor *	proactor = 0
	)

Initializes the factory with information which will be used with each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), {ACE_Handler::handle} will be called on the {handler} to get the correct handle.

void ACE_Asynch_Accept::operator= ( const ACE_Asynch_Accept &  )

private

Member Data Documentation

ACE_Asynch_Accept_Impl* ACE_Asynch_Accept::implementation_

protected

Delegation/implementation class that all methods will be forwarded to.

---

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

• Asynch_IO.h
• Asynch_IO.cpp