ACE_POSIX_AIOCB_Proactor Class Reference

This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the <aio_> operations issued. More...

#include <POSIX_Proactor.h>

Inheritance diagram for ACE_POSIX_AIOCB_Proactor:

Collaboration diagram for ACE_POSIX_AIOCB_Proactor:

Public Member Functions
	ACE_POSIX_AIOCB_Proactor (size_t nmaxop=ACE_AIO_DEFAULT_SIZE)
virtual Proactor_Type	get_impl_type ()
virtual	~ACE_POSIX_AIOCB_Proactor ()
	Destructor.
virtual int	close ()
	Close down the Proactor.
virtual int	handle_events (ACE_Time_Value &wait_time)
virtual int	handle_events ()
virtual int	post_completion (ACE_POSIX_Asynch_Result *result)
	Post a result to the completion port of the Proactor.
virtual int	start_aio (ACE_POSIX_Asynch_Result *result, ACE_POSIX_Proactor::Opcode op)
virtual int	cancel_aio (ACE_HANDLE h)
Public Member Functions inherited from ACE_POSIX_Proactor
virtual	~ACE_POSIX_Proactor ()
	Virtual destructor.
ACE_Asynch_Pseudo_Task &	get_asynch_pseudo_task ()
	Task to process pseudo-asynchronous operations.
virtual int	register_handle (ACE_HANDLE handle, const void *completion_key)
	This function is a no-op function for Unix systems. Returns 0.
int	wake_up_dispatch_threads ()
	@ This is a no-op on POSIX platforms. Returns 0.
int	close_dispatch_threads (int wait)
	@ This is a no-op on POSIX platforms. Returns 0.
size_t	number_of_threads () const
	@ This is a no-op on POSIX platforms. Returns 0.
void	number_of_threads (size_t threads)
	Set number of thread used as a parameter to CreatIoCompletionPort.
virtual ACE_HANDLE	get_handle () const
	This is a no-op in POSIX. Returns ACE_INVALID_HANDLE.
virtual ACE_Asynch_Read_Stream_Impl *	create_asynch_read_stream ()
	Create the correct implementation class for doing Asynch_Read_Stream.
virtual ACE_Asynch_Read_Stream_Result_Impl *	create_asynch_read_stream_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block &message_block, size_t bytes_to_read, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Read_Stream::Result class.
virtual ACE_Asynch_Write_Stream_Impl *	create_asynch_write_stream ()
	Create the correct implementation class for doing Asynch_Write_Stream.
virtual ACE_Asynch_Write_Stream_Result_Impl *	create_asynch_write_stream_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block &message_block, size_t bytes_to_write, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Write_Stream::Result.
virtual ACE_Asynch_Read_File_Impl *	create_asynch_read_file ()
	Create the correct implementation class for doing Asynch_Read_File.
virtual ACE_Asynch_Read_File_Result_Impl *	create_asynch_read_file_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block &message_block, size_t bytes_to_read, const void *act, u_long offset, u_long offset_high, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Read_File::Result.
virtual ACE_Asynch_Write_File_Impl *	create_asynch_write_file ()
	Create the correct implementation class for doing Asynch_Write_File.
virtual ACE_Asynch_Write_File_Result_Impl *	create_asynch_write_file_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block &message_block, size_t bytes_to_write, const void *act, u_long offset, u_long offset_high, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Write_File::Result.
virtual ACE_Asynch_Read_Dgram_Impl *	create_asynch_read_dgram ()
virtual ACE_Asynch_Read_Dgram_Result_Impl *	create_asynch_read_dgram_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block *message_block, size_t bytes_to_read, int flags, int protocol_family, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Read_Dgram::Result.
virtual ACE_Asynch_Write_Dgram_Impl *	create_asynch_write_dgram ()
virtual ACE_Asynch_Write_Dgram_Result_Impl *	create_asynch_write_dgram_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, ACE_Message_Block *message_block, size_t bytes_to_write, int flags, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Write_Dgram::Result.
virtual ACE_Asynch_Accept_Impl *	create_asynch_accept ()
	Create the correct implementation class for doing Asynch_Accept.
virtual ACE_Asynch_Accept_Result_Impl *	create_asynch_accept_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE listen_handle, ACE_HANDLE accept_handle, ACE_Message_Block &message_block, size_t bytes_to_read, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Accept::Result.
virtual ACE_Asynch_Connect_Impl *	create_asynch_connect ()
	Create the correct implementation class for doing Asynch_Connect.
virtual ACE_Asynch_Connect_Result_Impl *	create_asynch_connect_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE connect_handle, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Connect::Result.
virtual ACE_Asynch_Transmit_File_Impl *	create_asynch_transmit_file ()
	Create the correct implementation class for doing Asynch_Transmit_File.
virtual ACE_Asynch_Transmit_File_Result_Impl *	create_asynch_transmit_file_result (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE socket, ACE_HANDLE file, ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer, size_t bytes_to_write, u_long offset, u_long offset_high, size_t bytes_per_send, u_long flags, const void *act, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
	Create the correct implementation class for ACE_Asynch_Transmit_File::Result.
virtual ACE_Asynch_Result_Impl *	create_asynch_timer (const ACE_Handler::Proxy_Ptr &handler_proxy, const void *act, const ACE_Time_Value &tv, ACE_HANDLE event=ACE_INVALID_HANDLE, int priority=0, int signal_number=ACE_SIGRTMIN)
Public Member Functions inherited from ACE_Proactor_Impl
virtual	~ACE_Proactor_Impl ()
	Virtual destruction.
Public Member Functions inherited from ACE_Event_Handler
virtual	~ACE_Event_Handler ()=default
	Destructor is virtual to enable proper cleanup.
virtual void	set_handle (ACE_HANDLE)
	Set the I/O handle.
virtual int	priority () const
virtual void	priority (int priority)
	Set the priority of the Event_Handler.
virtual int	handle_input (ACE_HANDLE fd=ACE_INVALID_HANDLE)
	Called when input events occur (e.g., connection or data).
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_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
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.

Protected Member Functions
	ACE_POSIX_AIOCB_Proactor (size_t nmaxop, ACE_POSIX_Proactor::Proactor_Type ptype)
virtual int	get_result_status (ACE_POSIX_Asynch_Result *asynch_result, int &error_status, size_t &transfer_count)
int	create_result_aiocb_list ()
	Create aiocb list.
int	delete_result_aiocb_list ()
void	create_notify_manager ()
void	delete_notify_manager ()
void	check_max_aio_num ()
void	set_notify_handle (ACE_HANDLE h)
	To identify requests from Notify_Pipe_Manager.
int	handle_events_i (u_long milli_seconds)
int	start_deferred_aio ()
	Start deferred AIO if necessary.
virtual int	cancel_aiocb (ACE_POSIX_Asynch_Result *result)
	Cancel running or deferred AIO.
ACE_POSIX_Asynch_Result *	find_completed_aio (int &error_status, size_t &transfer_count, size_t &index, size_t &count)
	Extract the results of aio.
virtual ssize_t	allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
	Find free slot to store result and aiocb pointer.
virtual int	start_aio_i (ACE_POSIX_Asynch_Result *result)
	Initiate an aio operation.
virtual int	notify_completion (int sig_num)
int	putq_result (ACE_POSIX_Asynch_Result *result)
	Put "post_completed" result into the internal queue.
ACE_POSIX_Asynch_Result *	getq_result ()
	Get "post_completed" result from the internal queue.
int	clear_result_queue ()
	Clear the internal results queue.
int	process_result_queue ()
	Process the internal results queue.
Protected Member Functions inherited from ACE_POSIX_Proactor
	ACE_POSIX_Proactor ()
	Constructor.
void	application_specific_code (ACE_POSIX_Asynch_Result *asynch_result, size_t bytes_transferred, const void *completion_key, u_long error)
virtual int	post_wakeup_completions (int how_many)
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
ACE_AIOCB_Notify_Pipe_Manager *	aiocb_notify_pipe_manager_
aiocb **	aiocb_list_
ACE_POSIX_Asynch_Result **	result_list_
size_t	aiocb_list_max_size_
	To maintain the maximum size of the array (list).
size_t	aiocb_list_cur_size_
	To maintain the current size of the array (list).
ACE_SYNCH_MUTEX	mutex_
	Mutex to protect work with lists.
ACE_HANDLE	notify_pipe_read_handle_
size_t	num_deferred_aiocb_
size_t	num_started_aio_
	Number active,i.e. running requests.
ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >	result_queue_
	Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's.
Protected Attributes inherited from ACE_POSIX_Proactor
ACE_Handler	wakeup_handler_
int	os_id_
Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_
	Reference count.

Friends
class	ACE_AIOCB_Notify_Pipe_Manager
	Handler needs to call application specific code.
class	ACE_POSIX_Asynch_Operation
class	ACE_POSIX_Asynch_Accept
class	ACE_POSIX_Asynch_Connect

Additional Inherited Members
Public Types inherited from ACE_POSIX_Proactor
enum	Proactor_Type { PROACTOR_POSIX = 0 , PROACTOR_AIOCB = 1 , PROACTOR_SIG = 2 , PROACTOR_CB = 4 }
enum	SystemType {   ACE_OS_UNDEFINED = 0x0000 , ACE_OS_WIN = 0x0100 , ACE_OS_WIN_NT = ACE_OS_WIN | 0x0001 , ACE_OS_WIN_2000 = ACE_OS_WIN | 0x0002 ,   ACE_OS_LINUX = 0x0800 , ACE_OS_FREEBSD = 0x1000 , ACE_OS_IRIX = 0x2000 , ACE_OS_OPENBSD = 0x4000 }
enum	Opcode { ACE_OPCODE_READ = 1 , ACE_OPCODE_WRITE = 2 }
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.

Detailed Description

This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the <aio_> operations issued.

Constructor & Destructor Documentation

ACE_POSIX_AIOCB_Proactor() [1/2]

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor

(

size_t

nmaxop = ACE_AIO_DEFAULT_SIZE

)

Constructor defines max number asynchronous operations which can be started at the same time

~ACE_POSIX_AIOCB_Proactor()

ACE_POSIX_AIOCB_Proactor::~ACE_POSIX_AIOCB_Proactor ( )

virtual

Destructor.

ACE_POSIX_AIOCB_Proactor() [2/2]

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor ( size_t nmaxop, ACE_POSIX_Proactor::Proactor_Type ptype )

protected

Special constructor for ACE_SUN_Proactor and ACE_POSIX_SIG_Proactor

Member Function Documentation

allocate_aio_slot()

ssize_t ACE_POSIX_AIOCB_Proactor::allocate_aio_slot ( ACE_POSIX_Asynch_Result * result )

protectedvirtual

Find free slot to store result and aiocb pointer.

Reimplemented in ACE_POSIX_CB_Proactor.

cancel_aio()

int ACE_POSIX_AIOCB_Proactor::cancel_aio ( ACE_HANDLE h )

virtual

This method should be called from ACE_POSIX_Asynch_Operation::cancel() instead of usual ::aio_cancel. For all deferred AIO requests with handle "h" it removes its from the lists and notifies user. For all running AIO requests with handle "h" it calls ::aio_cancel. According to the POSIX standards we will receive ECANCELED for all ::aio_canceled AIO requests later on return from ::aio_suspend

Implements ACE_POSIX_Proactor.

cancel_aiocb()

int ACE_POSIX_AIOCB_Proactor::cancel_aiocb ( ACE_POSIX_Asynch_Result * result )

protectedvirtual

Cancel running or deferred AIO.

check_max_aio_num()

void ACE_POSIX_AIOCB_Proactor::check_max_aio_num ( )

protected

Define the maximum number of asynchronous I/O requests for the current OS

clear_result_queue()

int ACE_POSIX_AIOCB_Proactor::clear_result_queue ( )

protected

Clear the internal results queue.

close()

int ACE_POSIX_AIOCB_Proactor::close ( )

virtual

Close down the Proactor.

Reimplemented from ACE_POSIX_Proactor.

create_notify_manager()

void ACE_POSIX_AIOCB_Proactor::create_notify_manager ( )

protected

Call these methods from derived class when virtual table is built.

create_result_aiocb_list()

int ACE_POSIX_AIOCB_Proactor::create_result_aiocb_list ( )

protected

Create aiocb list.

delete_notify_manager()

void ACE_POSIX_AIOCB_Proactor::delete_notify_manager ( )

protected

delete_result_aiocb_list()

int ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list ( )

protected

Call this method from derived class when virtual table is built.

find_completed_aio()

ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::find_completed_aio ( int & error_status, size_t & transfer_count, size_t & index, size_t & count )

protected

Extract the results of aio.

get_impl_type()

ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_AIOCB_Proactor::get_impl_type ( )

virtual

Reimplemented from ACE_POSIX_Proactor.

Reimplemented in ACE_POSIX_CB_Proactor.

get_result_status()

int ACE_POSIX_AIOCB_Proactor::get_result_status ( ACE_POSIX_Asynch_Result * asynch_result, int & error_status, size_t & transfer_count )

protectedvirtual

Check AIO for completion, error and result status Return: 1 - AIO completed , 0 - not completed yet

getq_result()

ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::getq_result ( )

protected

Get "post_completed" result from the internal queue.

handle_events() [1/2]

int ACE_POSIX_AIOCB_Proactor::handle_events ( )

virtual

Block indefinitely until at least one event is dispatched. Dispatch a single set of events. If wait_time elapses before any events occur, return 0. Return 1 on success i.e., when a completion is dispatched, non-zero (-1) on errors and errno is set accordingly.

Implements ACE_POSIX_Proactor.

Reimplemented in ACE_POSIX_CB_Proactor.

handle_events() [2/2]

int ACE_POSIX_AIOCB_Proactor::handle_events ( ACE_Time_Value & wait_time )

virtual

Dispatch a single set of events. If wait_time elapses before any events occur, return 0. Return 1 on success i.e., when a completion is dispatched, non-zero (-1) on errors and errno is set accordingly.

Implements ACE_POSIX_Proactor.

Reimplemented in ACE_POSIX_CB_Proactor.

handle_events_i()

int ACE_POSIX_AIOCB_Proactor::handle_events_i ( u_long milli_seconds )

protected

Dispatch a single set of events. If <milli_seconds> elapses before any events occur, return 0. Return 1 if a completion dispatched. Return -1 on errors.

notify_completion()

int ACE_POSIX_AIOCB_Proactor::notify_completion ( int sig_num )

protectedvirtual

Notify queue of "post_completed" ACE_POSIX_Asynch_Results called from post_completion method

Reimplemented in ACE_POSIX_CB_Proactor.

post_completion()

int ACE_POSIX_AIOCB_Proactor::post_completion ( ACE_POSIX_Asynch_Result * result )

virtual

Post a result to the completion port of the Proactor.

Implements ACE_POSIX_Proactor.

process_result_queue()

int ACE_POSIX_AIOCB_Proactor::process_result_queue ( )

protected

Process the internal results queue.

putq_result()

int ACE_POSIX_AIOCB_Proactor::putq_result ( ACE_POSIX_Asynch_Result * result )

protected

Put "post_completed" result into the internal queue.

set_notify_handle()

void ACE_POSIX_AIOCB_Proactor::set_notify_handle ( ACE_HANDLE h )

protected

To identify requests from Notify_Pipe_Manager.

start_aio()

int ACE_POSIX_AIOCB_Proactor::start_aio ( ACE_POSIX_Asynch_Result * result, ACE_POSIX_Proactor::Opcode op )

virtual

Implements ACE_POSIX_Proactor.

start_aio_i()

int ACE_POSIX_AIOCB_Proactor::start_aio_i ( ACE_POSIX_Asynch_Result * result )

protectedvirtual

Initiate an aio operation.

start_deferred_aio()

int ACE_POSIX_AIOCB_Proactor::start_deferred_aio ( )

protected

Start deferred AIO if necessary.

Friends And Related Symbol Documentation

ACE_AIOCB_Notify_Pipe_Manager

friend class ACE_AIOCB_Notify_Pipe_Manager

friend

Handler needs to call application specific code.

ACE_POSIX_Asynch_Accept

friend class ACE_POSIX_Asynch_Accept

friend

ACE_POSIX_Asynch_Connect

friend class ACE_POSIX_Asynch_Connect

friend

ACE_POSIX_Asynch_Operation

friend class ACE_POSIX_Asynch_Operation

friend

This class does the registering of Asynch Operations with the Proactor which is necessary in the AIOCB strategy.

Member Data Documentation

aiocb_list_

aiocb** ACE_POSIX_AIOCB_Proactor::aiocb_list_

protected

Use a dynamically allocated array to keep track of all the aio's issued currently.

aiocb_list_cur_size_

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_cur_size_

protected

To maintain the current size of the array (list).

aiocb_list_max_size_

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_max_size_

protected

To maintain the maximum size of the array (list).

aiocb_notify_pipe_manager_

ACE_AIOCB_Notify_Pipe_Manager* ACE_POSIX_AIOCB_Proactor::aiocb_notify_pipe_manager_

protected

This class takes care of doing <accept> when we use AIO_CONTROL_BLOCKS strategy.

mutex_

ACE_SYNCH_MUTEX ACE_POSIX_AIOCB_Proactor::mutex_

protected

Mutex to protect work with lists.

notify_pipe_read_handle_

ACE_HANDLE ACE_POSIX_AIOCB_Proactor::notify_pipe_read_handle_

protected

The purpose of this member is only to identify asynchronous request from NotifyManager. We will reserve for it always slot 0 in the list of aiocb's to be sure that don't lose notifications.

num_deferred_aiocb_

size_t ACE_POSIX_AIOCB_Proactor::num_deferred_aiocb_

protected

Number of ACE_POSIX_Asynch_Result's waiting for start i.e. deferred AIOs

num_started_aio_

size_t ACE_POSIX_AIOCB_Proactor::num_started_aio_

protected

Number active,i.e. running requests.

result_list_

ACE_POSIX_Asynch_Result** ACE_POSIX_AIOCB_Proactor::result_list_

protected

result_queue_

ACE_Unbounded_Queue<ACE_POSIX_Asynch_Result *> ACE_POSIX_AIOCB_Proactor::result_queue_

protected

Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's.

---

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

• POSIX_Proactor.h
• POSIX_Proactor.cpp