ACE  6.4.2
Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
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:
Inheritance graph
[legend]
Collaboration diagram for ACE_POSIX_AIOCB_Proactor:
Collaboration graph
[legend]

Public Member Functions

 ACE_POSIX_AIOCB_Proactor (size_t nmaxop=ACE_AIO_DEFAULT_SIZE)
 
virtual Proactor_Type get_impl_type (void)
 
virtual ~ACE_POSIX_AIOCB_Proactor (void)
 Destructor. More...
 
virtual int close (void)
 Close down the Proactor. More...
 
virtual int handle_events (ACE_Time_Value &wait_time)
 
virtual int handle_events (void)
 
virtual int post_completion (ACE_POSIX_Asynch_Result *result)
 Post a result to the completion port of the Proactor. More...
 
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 (void)
 Virtual destructor. More...
 
ACE_Asynch_Pseudo_Taskget_asynch_pseudo_task ()
 Task to process pseudo-asynchronous operations. More...
 
virtual int register_handle (ACE_HANDLE handle, const void *completion_key)
 This function is a no-op function for Unix systems. Returns 0. More...
 
int wake_up_dispatch_threads (void)
 @ This is a no-op on POSIX platforms. Returns 0. More...
 
int close_dispatch_threads (int wait)
 @ This is a no-op on POSIX platforms. Returns 0. More...
 
size_t number_of_threads (void) const
 @ This is a no-op on POSIX platforms. Returns 0. More...
 
void number_of_threads (size_t threads)
 Set number of thread used as a parameter to CreatIoCompletionPort. More...
 
virtual ACE_HANDLE get_handle (void) const
 This is a no-op in POSIX. Returns ACE_INVALID_HANDLE. More...
 
virtual ACE_Asynch_Read_Stream_Implcreate_asynch_read_stream (void)
 Create the correct implementation class for doing Asynch_Read_Stream. More...
 
virtual ACE_Asynch_Read_Stream_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Write_Stream_Implcreate_asynch_write_stream (void)
 Create the correct implementation class for doing Asynch_Write_Stream. More...
 
virtual ACE_Asynch_Write_Stream_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Read_File_Implcreate_asynch_read_file (void)
 Create the correct implementation class for doing Asynch_Read_File. More...
 
virtual ACE_Asynch_Read_File_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Write_File_Implcreate_asynch_write_file (void)
 Create the correct implementation class for doing Asynch_Write_File. More...
 
virtual ACE_Asynch_Write_File_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Read_Dgram_Implcreate_asynch_read_dgram (void)
 
virtual ACE_Asynch_Read_Dgram_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Write_Dgram_Implcreate_asynch_write_dgram (void)
 
virtual ACE_Asynch_Write_Dgram_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Accept_Implcreate_asynch_accept (void)
 Create the correct implementation class for doing Asynch_Accept. More...
 
virtual ACE_Asynch_Accept_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Connect_Implcreate_asynch_connect (void)
 Create the correct implementation class for doing Asynch_Connect. More...
 
virtual ACE_Asynch_Connect_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Transmit_File_Implcreate_asynch_transmit_file (void)
 Create the correct implementation class for doing Asynch_Transmit_File. More...
 
virtual ACE_Asynch_Transmit_File_Result_Implcreate_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. More...
 
virtual ACE_Asynch_Result_Implcreate_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 (void)
 Virtual destruction. More...
 
- Public Member Functions inherited from ACE_Event_Handler
virtual ~ACE_Event_Handler (void)
 Destructor is virtual to enable proper cleanup. More...
 
virtual void set_handle (ACE_HANDLE)
 Set the I/O handle. More...
 
virtual int priority (void) const
 
virtual void priority (int priority)
 Set the priority of the Event_Handler. More...
 
virtual int handle_input (ACE_HANDLE fd=ACE_INVALID_HANDLE)
 Called when input events occur (e.g., connection or data). More...
 
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). More...
 
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. More...
 
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 (void)
 
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. More...
 
virtual ACE_Reactorreactor (void) const
 Get the event demultiplexors. More...
 
virtual ACE_Reactor_Timer_Interfacereactor_timer_interface (void) const
 Get only the reactor's timer related interface. More...
 
virtual Reference_Count add_reference (void)
 Increment reference count on the handler. More...
 
virtual Reference_Count remove_reference (void)
 Decrement reference count on the handler. More...
 
Reference_Counting_Policyreference_counting_policy (void)
 Current Reference_Counting_Policy. More...
 

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 (void)
 Create aiocb list. More...
 
int delete_result_aiocb_list (void)
 
void create_notify_manager (void)
 
void delete_notify_manager (void)
 
void check_max_aio_num (void)
 
void set_notify_handle (ACE_HANDLE h)
 To identify requests from Notify_Pipe_Manager. More...
 
int handle_events_i (u_long milli_seconds)
 
int start_deferred_aio (void)
 Start deferred AIO if necessary. More...
 
virtual int cancel_aiocb (ACE_POSIX_Asynch_Result *result)
 Cancel running or deferred AIO. More...
 
ACE_POSIX_Asynch_Resultfind_completed_aio (int &error_status, size_t &transfer_count, size_t &index, size_t &count)
 Extract the results of aio. More...
 
virtual ssize_t allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
 Find free slot to store result and aiocb pointer. More...
 
virtual int start_aio_i (ACE_POSIX_Asynch_Result *result)
 Initiate an aio operation. More...
 
virtual int notify_completion (int sig_num)
 
int putq_result (ACE_POSIX_Asynch_Result *result)
 Put "post_completed" result into the internal queue. More...
 
ACE_POSIX_Asynch_Resultgetq_result (void)
 Get "post_completed" result from the internal queue. More...
 
int clear_result_queue (void)
 Clear the internal results queue. More...
 
int process_result_queue (void)
 Process the internal results queue. More...
 
- Protected Member Functions inherited from ACE_POSIX_Proactor
 ACE_POSIX_Proactor (void)
 Constructor. More...
 
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 *=0, int priority=ACE_Event_Handler::LO_PRIORITY)
 Force ACE_Event_Handler to be an abstract base class. More...
 

Protected Attributes

ACE_AIOCB_Notify_Pipe_Manageraiocb_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). More...
 
size_t aiocb_list_cur_size_
 To maintain the current size of the array (list). More...
 
ACE_SYNCH_MUTEX mutex_
 Mutex to protect work with lists. More...
 
ACE_HANDLE notify_pipe_read_handle_
 
size_t num_deferred_aiocb_
 
size_t num_started_aio_
 Number active,i.e. running requests. More...
 
ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * > result_queue_
 Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's. More...
 
- 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. More...
 

Friends

class ACE_AIOCB_Notify_Pipe_Manager
 Handler needs to call application specific code. More...
 
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_SUN = 3,
  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_SUN = 0x0200, ACE_OS_SUN_55 = ACE_OS_SUN | 0x0001, ACE_OS_SUN_56 = ACE_OS_SUN | 0x0002, ACE_OS_SUN_57 = ACE_OS_SUN | 0x0004,
  ACE_OS_SUN_58 = ACE_OS_SUN | 0x0008, ACE_OS_HPUX = 0x0400, ACE_OS_HPUX_11 = ACE_OS_HPUX | 0x0001, 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. More...
 
- 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. More...
 
- Protected Types inherited from ACE_Event_Handler
typedef ACE_Atomic_Op< ACE_SYNCH_MUTEX, Reference_CountAtomic_Reference_Count
 Typedef for implementation of reference counting. More...
 

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::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 ( void  )
virtual

Destructor.

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

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.

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.

int ACE_POSIX_AIOCB_Proactor::cancel_aiocb ( ACE_POSIX_Asynch_Result result)
protectedvirtual

Cancel running or deferred AIO.

void ACE_POSIX_AIOCB_Proactor::check_max_aio_num ( void  )
protected

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

int ACE_POSIX_AIOCB_Proactor::clear_result_queue ( void  )
protected

Clear the internal results queue.

int ACE_POSIX_AIOCB_Proactor::close ( void  )
virtual

Close down the Proactor.

Reimplemented from ACE_POSIX_Proactor.

void ACE_POSIX_AIOCB_Proactor::create_notify_manager ( void  )
protected

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

int ACE_POSIX_AIOCB_Proactor::create_result_aiocb_list ( void  )
protected

Create aiocb list.

void ACE_POSIX_AIOCB_Proactor::delete_notify_manager ( void  )
protected
int ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list ( void  )
protected

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

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.

ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_AIOCB_Proactor::get_impl_type ( void  )
virtual

Reimplemented from ACE_POSIX_Proactor.

Reimplemented in ACE_POSIX_CB_Proactor.

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

ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::getq_result ( void  )
protected

Get "post_completed" result from the internal queue.

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.

int ACE_POSIX_AIOCB_Proactor::handle_events ( void  )
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.

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.

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.

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.

int ACE_POSIX_AIOCB_Proactor::process_result_queue ( void  )
protected

Process the internal results queue.

int ACE_POSIX_AIOCB_Proactor::putq_result ( ACE_POSIX_Asynch_Result result)
protected

Put "post_completed" result into the internal queue.

void ACE_POSIX_AIOCB_Proactor::set_notify_handle ( ACE_HANDLE  h)
protected

To identify requests from Notify_Pipe_Manager.

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

Implements ACE_POSIX_Proactor.

int ACE_POSIX_AIOCB_Proactor::start_aio_i ( ACE_POSIX_Asynch_Result result)
protectedvirtual

Initiate an aio operation.

int ACE_POSIX_AIOCB_Proactor::start_deferred_aio ( void  )
protected

Start deferred AIO if necessary.

Friends And Related Function Documentation

friend class ACE_AIOCB_Notify_Pipe_Manager
friend

Handler needs to call application specific code.

friend class ACE_POSIX_Asynch_Accept
friend
friend class ACE_POSIX_Asynch_Connect
friend
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** ACE_POSIX_AIOCB_Proactor::aiocb_list_
protected

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

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_cur_size_
protected

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

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_max_size_
protected

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

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.

ACE_SYNCH_MUTEX ACE_POSIX_AIOCB_Proactor::mutex_
protected

Mutex to protect work with lists.

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.

size_t ACE_POSIX_AIOCB_Proactor::num_deferred_aiocb_
protected

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

size_t ACE_POSIX_AIOCB_Proactor::num_started_aio_
protected

Number active,i.e. running requests.

ACE_POSIX_Asynch_Result** ACE_POSIX_AIOCB_Proactor::result_list_
protected
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: