ACE_POSIX_Asynch_Accept Class Reference

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 ()
	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 ()
int	close ()
ACE_HANDLE	get_handle () 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
Public Member Functions inherited from ACE_Asynch_Accept_Impl
virtual	~ACE_Asynch_Accept_Impl ()
Public Member Functions inherited from ACE_Asynch_Operation_Impl
virtual	~ACE_Asynch_Operation_Impl ()
Public Member Functions inherited from ACE_POSIX_Asynch_Operation
int	open (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, const void *completion_key, ACE_Proactor *proactor=0)
int	cancel ()
	Check the documentation for ACE_Asynch_Operation::cancel.
ACE_Proactor *	proactor () const
	Return the underlying proactor.
ACE_POSIX_Proactor *	posix_proactor () const
	Return the underlying Proactor implementation.
Public Member Functions inherited from ACE_Event_Handler
virtual	~ACE_Event_Handler ()=default
	Destructor is virtual to enable proper cleanup.
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	handle_signal (int signum, siginfo_t *=0, ucontext_t *=0)
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.

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_

Additional Inherited Members
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.
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.
Protected Member Functions inherited from ACE_Asynch_Accept_Impl
	ACE_Asynch_Accept_Impl ()
	Do-nothing constructor.
Protected Member Functions inherited from ACE_Asynch_Operation_Impl
	ACE_Asynch_Operation_Impl ()
	Do-nothing constructor.
Protected Member Functions inherited from ACE_POSIX_Asynch_Operation
	ACE_POSIX_Asynch_Operation (ACE_POSIX_Proactor *posix_proactor)
	Constructor.
virtual	~ACE_POSIX_Asynch_Operation ()
	Destructor.
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 inherited from ACE_POSIX_Asynch_Operation
ACE_POSIX_Proactor *	posix_proactor_
ACE_Proactor *	proactor_
	Proactor that this Asynch IO will be registered with.
ACE_Handler::Proxy_Ptr	handler_proxy_
	Handler that will receive the callback.
ACE_HANDLE	handle_
	I/O handle used for reading.
Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_
	Reference count.

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_Asynch_Accept

(

ACE_POSIX_Proactor *

posix_proactor

)

Constructor.

~ACE_POSIX_Asynch_Accept()

ACE_POSIX_Asynch_Accept::~ACE_POSIX_Asynch_Accept ( )

virtual

Destructor.

Member Function Documentation

accept()

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.

cancel()

int ACE_POSIX_Asynch_Accept::cancel ( )

virtual

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

Implements ACE_Asynch_Operation_Impl.

cancel_uncompleted()

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

close()

int ACE_POSIX_Asynch_Accept::close

(

)

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

get_handle()

ACE_HANDLE ACE_POSIX_Asynch_Accept::get_handle ( ) const

virtual

virtual from ACE_Event_Handler

Reimplemented from ACE_Event_Handler.

handle_close()

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.

handle_input()

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.

open()

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.

Implements ACE_Asynch_Operation_Impl.

set_handle()

void ACE_POSIX_Asynch_Accept::set_handle ( ACE_HANDLE handle )

virtual

virtual from ACE_Event_Handler

Reimplemented from ACE_Event_Handler.

Member Data Documentation

flg_open_

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

lock_

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.

result_queue_

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:

• POSIX_Asynch_IO.h
• POSIX_Asynch_IO.cpp