#include <POSIX_Proactor.h>
Inheritance diagram for ACE_POSIX_Proactor:
Public Types | |
PROACTOR_POSIX = 0 | |
Base class type. | |
PROACTOR_AIOCB = 1 | |
Aio_suspend() based. | |
PROACTOR_SIG = 2 | |
Signals notifications. | |
PROACTOR_SUN = 3 | |
SUN specific aiowait(). | |
PROACTOR_CB = 4 | |
Callback notifications. | |
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 | |
ACE_OPCODE_READ = 1 | |
ACE_OPCODE_WRITE = 2 | |
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 Member Functions | |
virtual Proactor_Type | get_impl_type (void) |
virtual | ~ACE_POSIX_Proactor (void) |
Virtual destructor. | |
virtual int | close (void) |
Close down the Proactor. | |
virtual int | handle_events (ACE_Time_Value &wait_time)=0 |
virtual int | handle_events (void)=0 |
virtual int | post_completion (ACE_POSIX_Asynch_Result *result)=0 |
virtual int | start_aio (ACE_POSIX_Asynch_Result *result, Opcode op)=0 |
virtual int | cancel_aio (ACE_HANDLE h)=0 |
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 (void) |
@ 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 (void) 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 (void) const |
This is a no-op in POSIX. Returns ACE_INVALID_HANDLE. | |
virtual ACE_Asynch_Read_Stream_Impl * | create_asynch_read_stream (void) |
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 (void) |
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 (void) |
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 (void) |
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 (void) |
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 (void) |
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 (void) |
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 (void) |
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 (void) |
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) |
Protected Member Functions | |
ACE_POSIX_Proactor (void) | |
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 Attributes | |
ACE_Handler | wakeup_handler_ |
int | os_id_ |
Private Attributes | |
ACE_Asynch_Pseudo_Task | pseudo_task_ |
Task to process pseudo-asynchronous accept/connect. |
There are two different strategies by which Proactor can get to know the completion of <aio> operations. One is based on Asynchronous I/O Control Blocks (AIOCB) where a list of AIOCBs are stored and completion status of the corresponding operations are queried on them. The other one is based on POSIX Real Time signals. This class abstracts out the common code needed for both the strategies. <ACE_POSIX_AIOCB_Proactor> and <ACE_POSIX_SIG_Proactor> specialize this class for each strategy.
ACE_POSIX_Proactor::~ACE_POSIX_Proactor | ( | void | ) | [virtual] |
Virtual destructor.
ACE_POSIX_Proactor::ACE_POSIX_Proactor | ( | void | ) | [protected] |
Constructor.
void ACE_POSIX_Proactor::application_specific_code | ( | ACE_POSIX_Asynch_Result * | asynch_result, | |
size_t | bytes_transferred, | |||
const void * | completion_key, | |||
u_long | error | |||
) | [protected] |
Protect against structured exceptions caused by user code when dispatching handles. The <completion_key> is not very useful compared to <AST> that can be associated each asynchronous operation. <completion_key> is implemented right now for the POSIX Proators.
virtual int ACE_POSIX_Proactor::cancel_aio | ( | ACE_HANDLE | h | ) | [pure virtual] |
Implemented in ACE_POSIX_AIOCB_Proactor.
int ACE_POSIX_Proactor::close | ( | void | ) | [virtual] |
int ACE_POSIX_Proactor::close_dispatch_threads | ( | int | wait | ) | [virtual] |
ACE_Asynch_Accept_Impl * ACE_POSIX_Proactor::create_asynch_accept | ( | void | ) | [virtual] |
ACE_Asynch_Accept_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Accept::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Connect_Impl * ACE_POSIX_Proactor::create_asynch_connect | ( | void | ) | [virtual] |
ACE_Asynch_Connect_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Connect::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Read_Dgram_Impl * ACE_POSIX_Proactor::create_asynch_read_dgram | ( | void | ) | [virtual] |
Create the correct implementation class for doing Asynch_Read_Dgram.
Implements ACE_Proactor_Impl.
ACE_Asynch_Read_Dgram_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Read_Dgram::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Read_File_Impl * ACE_POSIX_Proactor::create_asynch_read_file | ( | void | ) | [virtual] |
ACE_Asynch_Read_File_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Read_File::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Read_Stream_Impl * ACE_POSIX_Proactor::create_asynch_read_stream | ( | void | ) | [virtual] |
ACE_Asynch_Read_Stream_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Read_Stream::Result class.
Implements ACE_Proactor_Impl.
ACE_Asynch_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create a timer result object which can be used with the Timer mechanism of the Proactor.
Implements ACE_Proactor_Impl.
ACE_Asynch_Transmit_File_Impl * ACE_POSIX_Proactor::create_asynch_transmit_file | ( | void | ) | [virtual] |
Create the correct implementation class for doing Asynch_Transmit_File.
Implements ACE_Proactor_Impl.
ACE_Asynch_Transmit_File_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Transmit_File::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Write_Dgram_Impl * ACE_POSIX_Proactor::create_asynch_write_dgram | ( | void | ) | [virtual] |
Create the correct implementation class for doing Asynch_Write_Dgram.
Implements ACE_Proactor_Impl.
ACE_Asynch_Write_Dgram_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Write_Dgram::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Write_File_Impl * ACE_POSIX_Proactor::create_asynch_write_file | ( | void | ) | [virtual] |
ACE_Asynch_Write_File_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Write_File::Result.
Implements ACE_Proactor_Impl.
ACE_Asynch_Write_Stream_Impl * ACE_POSIX_Proactor::create_asynch_write_stream | ( | void | ) | [virtual] |
Create the correct implementation class for doing Asynch_Write_Stream.
Implements ACE_Proactor_Impl.
ACE_Asynch_Write_Stream_Result_Impl * ACE_POSIX_Proactor::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 | |||
) | [virtual] |
Create the correct implementation class for ACE_Asynch_Write_Stream::Result.
Implements ACE_Proactor_Impl.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Asynch_Pseudo_Task & ACE_POSIX_Proactor::get_asynch_pseudo_task | ( | ) |
Task to process pseudo-asynchronous operations.
ACE_HANDLE ACE_POSIX_Proactor::get_handle | ( | void | ) | const [virtual] |
ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_Proactor::get_impl_type | ( | void | ) | [virtual] |
Reimplemented in ACE_POSIX_CB_Proactor, and ACE_POSIX_AIOCB_Proactor.
virtual int ACE_POSIX_Proactor::handle_events | ( | void | ) | [pure virtual] |
Block indefinitely until at least one event is dispatched. Dispatch a single set of events.Return 1 on success i.e., when a completion is dispatched, non-zero (-1) on errors and errno is set accordingly.
Implements ACE_Proactor_Impl.
Implemented in ACE_POSIX_CB_Proactor, and ACE_POSIX_AIOCB_Proactor.
virtual int ACE_POSIX_Proactor::handle_events | ( | ACE_Time_Value & | wait_time | ) | [pure 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_Proactor_Impl.
Implemented in ACE_POSIX_CB_Proactor, and ACE_POSIX_AIOCB_Proactor.
void ACE_POSIX_Proactor::number_of_threads | ( | size_t | threads | ) | [virtual] |
size_t ACE_POSIX_Proactor::number_of_threads | ( | void | ) | const [virtual] |
virtual int ACE_POSIX_Proactor::post_completion | ( | ACE_POSIX_Asynch_Result * | result | ) | [pure virtual] |
Post a result to the completion port of the Proactor. If errors occur, the result will be deleted by this method. If successful, the result will be deleted by the Proactor when the result is removed from the completion port. Therefore, the result should have been dynamically allocated and should be orphaned by the user once this method is called.
Implemented in ACE_POSIX_AIOCB_Proactor.
int ACE_POSIX_Proactor::post_wakeup_completions | ( | int | how_many | ) | [protected, virtual] |
Post <how_many> completions to the completion port so that all threads can wake up. This is used in conjunction with the <run_event_loop>.
Implements ACE_Proactor_Impl.
int ACE_POSIX_Proactor::register_handle | ( | ACE_HANDLE | handle, | |
const void * | completion_key | |||
) | [virtual] |
virtual int ACE_POSIX_Proactor::start_aio | ( | ACE_POSIX_Asynch_Result * | result, | |
Opcode | op | |||
) | [pure virtual] |
Implemented in ACE_POSIX_AIOCB_Proactor.
int ACE_POSIX_Proactor::wake_up_dispatch_threads | ( | void | ) | [virtual] |
int ACE_POSIX_Proactor::os_id_ [protected] |
Task to process pseudo-asynchronous accept/connect.
ACE_Handler ACE_POSIX_Proactor::wakeup_handler_ [protected] |
Handler to handle the wakeups. This works in conjunction with the <ACE_Proactor::run_event_loop>.