For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN) More...

#include <POSIX_Asynch_IO.h>

Inheritance diagram for ACE_POSIX_Asynch_Accept:

Collaboration diagram for ACE_POSIX_Asynch_Accept:

Public Member Functions
	ACE_POSIX_Asynch_Accept (ACE_POSIX_Proactor *posix_proactor)
	Constructor.
virtual	~ACE_POSIX_Asynch_Accept (void)
	Destructor.
int	open (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, const void completion_key, ACE_Proactor proactor=0)
int	accept (ACE_Message_Block &message_block, size_t bytes_to_read, ACE_HANDLE accept_handle, const void *act, int priority, int signal_number=0, int addr_family=AF_INET)
int	cancel (void)
int	close ()
ACE_HANDLE	get_handle (void) const
	virtual from ACE_Event_Handler
void	set_handle (ACE_HANDLE handle)
	virtual from ACE_Event_Handler
int	handle_input (ACE_HANDLE handle)
int	handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
	virtual from ACE_Event_Handler
Private Member Functions
int	cancel_uncompleted (int flg_notify)
Private Attributes
bool	flg_open_
ACE_Unbounded_Queue < ACE_POSIX_Asynch_Accept_Result * >	result_queue_
ACE_SYNCH_MUTEX	lock_

Detailed Description

For the POSIX implementation this class is common for all Proactors (AIOCB/SIG/SUN)

Constructor & Destructor Documentation

ACE_POSIX_Asynch_Accept::ACE_POSIX_Asynch_Accept ( ACE_POSIX_Proactor * posix_proactor )

Constructor.

ACE_POSIX_Asynch_Accept::~ACE_POSIX_Asynch_Accept ( void ) [virtual]

Destructor.

Member Function Documentation

int ACE_POSIX_Asynch_Accept::accept	(	ACE_Message_Block &	message_block,
		size_t	bytes_to_read,
		ACE_HANDLE	accept_handle,
		const void *	act,
		int	priority,
		int	signal_number = `0`,
		int	addr_family = `AF_INET`
	)		`[virtual]`

This starts off an asynchronous accept. The asynchronous accept call also allows any initial data to be returned to the handler. Upto bytes_to_read will be read and stored in the message_block. The <accept_handle> will be used for the <accept> call. If (<accept_handle> == INVALID_HANDLE), a new handle will be created.

message_block must be specified. This is because the address of the new connection is placed at the end of this buffer.

Implements ACE_Asynch_Accept_Impl.

int ACE_POSIX_Asynch_Accept::cancel ( void ) [virtual]

Cancel all pending pseudo-asynchronus requests Behavior as usual AIO request

Reimplemented from ACE_POSIX_Asynch_Operation.

int ACE_POSIX_Asynch_Accept::cancel_uncompleted ( int flg_notify ) [private]

flg_notify points whether or not we should send notification about canceled accepts Parameter flg_notify can be 0 - don't send notifications about canceled accepts 1 - notify user about canceled accepts according POSIX standards we should receive notifications on canceled AIO requests

int ACE_POSIX_Asynch_Accept::close ( void )

Close performs cancellation of all pending requests and closure the listen handle

ACE_HANDLE ACE_POSIX_Asynch_Accept::get_handle ( void ) const [virtual]

virtual from ACE_Event_Handler

Reimplemented from ACE_Event_Handler.

int ACE_POSIX_Asynch_Accept::handle_close	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	close_mask
	)		`[virtual]`

virtual from ACE_Event_Handler

Reimplemented from ACE_Event_Handler.

int ACE_POSIX_Asynch_Accept::handle_input ( ACE_HANDLE handle ) [virtual]

virtual from ACE_Event_Handler Called when accept event comes up on <listen_handle>

Reimplemented from ACE_Event_Handler.

int ACE_POSIX_Asynch_Accept::open	(	const ACE_Handler::Proxy_Ptr &	handler_proxy,
		ACE_HANDLE	handle,
		const void *	completion_key,
		ACE_Proactor *	proactor = `0`
	)		`[virtual]`

This <open> belongs to ACE_POSIX_Asynch_Operation. We forward this call to that method. We have put this here to avoid the compiler warnings.

Reimplemented from ACE_POSIX_Asynch_Operation.

void ACE_POSIX_Asynch_Accept::set_handle ( ACE_HANDLE handle ) [virtual]

virtual from ACE_Event_Handler

Reimplemented from ACE_Event_Handler.

Member Data Documentation

bool ACE_POSIX_Asynch_Accept::flg_open_ [private]

true - Accept is registered in ACE_Asynch_Pseudo_Task false - Accept is deregisted in ACE_Asynch_Pseudo_Task

ACE_SYNCH_MUTEX ACE_POSIX_Asynch_Accept::lock_ [private]

The lock to protect the result queue which is shared. The queue is updated by main thread in the register function call and through the auxillary thread in the deregister fun. So let us mutex it.

ACE_Unbounded_Queue<ACE_POSIX_Asynch_Accept_Result*> ACE_POSIX_Asynch_Accept::result_queue_ [private]

Queue of Result pointers that correspond to all the pending accept operations.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation