ACE_POSIX_Proactor Class Reference

POSIX implementation of the Proactor. More...

#include <POSIX_Proactor.h>

Inheritance diagram for ACE_POSIX_Proactor:

Collaboration diagram for ACE_POSIX_Proactor:

Public Types
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.

Public Member Functions
virtual Proactor_Type	get_impl_type ()
virtual	~ACE_POSIX_Proactor ()
	Virtual destructor.
virtual int	close ()
	Close down the Proactor.
virtual int	handle_events (ACE_Time_Value &wait_time)=0
virtual int	handle_events ()=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 ()
	@ 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_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_Handler	wakeup_handler_
int	os_id_
Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_
	Reference count.

Private Attributes
ACE_Asynch_Pseudo_Task	pseudo_task_
	Task to process pseudo-asynchronous accept/connect.

Additional Inherited Members
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

POSIX implementation of the Proactor.

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.

Member Enumeration Documentation

Opcode

enum ACE_POSIX_Proactor::Opcode

Enumerator
ACE_OPCODE_READ
ACE_OPCODE_WRITE

Proactor_Type

enum ACE_POSIX_Proactor::Proactor_Type

Enumerator
PROACTOR_POSIX	Base class type.
PROACTOR_AIOCB	Aio_suspend() based.
PROACTOR_SIG	Signals notifications.
PROACTOR_CB	Callback notifications.

SystemType

enum ACE_POSIX_Proactor::SystemType

Enumerator
ACE_OS_UNDEFINED
ACE_OS_WIN
ACE_OS_WIN_NT
ACE_OS_WIN_2000
ACE_OS_LINUX
ACE_OS_FREEBSD
ACE_OS_IRIX
ACE_OS_OPENBSD

Constructor & Destructor Documentation

~ACE_POSIX_Proactor()

ACE_POSIX_Proactor::~ACE_POSIX_Proactor ( )

virtual

Virtual destructor.

ACE_POSIX_Proactor()

ACE_POSIX_Proactor::ACE_POSIX_Proactor ( )

protected

Constructor.

Member Function Documentation

application_specific_code()

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.

cancel_aio()

virtual int ACE_POSIX_Proactor::cancel_aio ( ACE_HANDLE h )

pure virtual

Implemented in ACE_POSIX_AIOCB_Proactor.

close()

int ACE_POSIX_Proactor::close ( )

virtual

Close down the Proactor.

Implements ACE_Proactor_Impl.

Reimplemented in ACE_POSIX_AIOCB_Proactor.

close_dispatch_threads()

int ACE_POSIX_Proactor::close_dispatch_threads ( int wait )

virtual

@ This is a no-op on POSIX platforms. Returns 0.

Implements ACE_Proactor_Impl.

create_asynch_accept()

ACE_Asynch_Accept_Impl * ACE_POSIX_Proactor::create_asynch_accept ( )

virtual

Create the correct implementation class for doing Asynch_Accept.

Implements ACE_Proactor_Impl.

create_asynch_accept_result()

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.

create_asynch_connect()

ACE_Asynch_Connect_Impl * ACE_POSIX_Proactor::create_asynch_connect ( )

virtual

Create the correct implementation class for doing Asynch_Connect.

Implements ACE_Proactor_Impl.

create_asynch_connect_result()

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.

create_asynch_read_dgram()

ACE_Asynch_Read_Dgram_Impl * ACE_POSIX_Proactor::create_asynch_read_dgram ( )

virtual

Create the correct implementation class for doing Asynch_Read_Dgram.

Implements ACE_Proactor_Impl.

create_asynch_read_dgram_result()

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.

create_asynch_read_file()

ACE_Asynch_Read_File_Impl * ACE_POSIX_Proactor::create_asynch_read_file ( )

virtual

Create the correct implementation class for doing Asynch_Read_File.

Implements ACE_Proactor_Impl.

create_asynch_read_file_result()

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.

create_asynch_read_stream()

ACE_Asynch_Read_Stream_Impl * ACE_POSIX_Proactor::create_asynch_read_stream ( )

virtual

Create the correct implementation class for doing Asynch_Read_Stream.

Implements ACE_Proactor_Impl.

create_asynch_read_stream_result()

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.

create_asynch_timer()

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.

create_asynch_transmit_file()

ACE_Asynch_Transmit_File_Impl * ACE_POSIX_Proactor::create_asynch_transmit_file ( )

virtual

Create the correct implementation class for doing Asynch_Transmit_File.

Implements ACE_Proactor_Impl.

create_asynch_transmit_file_result()

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.

create_asynch_write_dgram()

ACE_Asynch_Write_Dgram_Impl * ACE_POSIX_Proactor::create_asynch_write_dgram ( )

virtual

Create the correct implementation class for doing Asynch_Write_Dgram.

Implements ACE_Proactor_Impl.

create_asynch_write_dgram_result()

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.

create_asynch_write_file()

ACE_Asynch_Write_File_Impl * ACE_POSIX_Proactor::create_asynch_write_file ( )

virtual

Create the correct implementation class for doing Asynch_Write_File.

Implements ACE_Proactor_Impl.

create_asynch_write_file_result()

ACE_Asynch_Write_File_Result_Impl * ACE_POSIX_Proactor::create_asynch_write_file_result ( const ACE_Handler::Proxy_Ptr & handler, 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.

create_asynch_write_stream()

ACE_Asynch_Write_Stream_Impl * ACE_POSIX_Proactor::create_asynch_write_stream ( )

virtual

Create the correct implementation class for doing Asynch_Write_Stream.

Implements ACE_Proactor_Impl.

create_asynch_write_stream_result()

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.

get_asynch_pseudo_task()

ACE_Asynch_Pseudo_Task & ACE_POSIX_Proactor::get_asynch_pseudo_task ( )

inline

Task to process pseudo-asynchronous operations.

get_handle()

ACE_HANDLE ACE_POSIX_Proactor::get_handle ( ) const

virtual

This is a no-op in POSIX. Returns ACE_INVALID_HANDLE.

Implements ACE_Proactor_Impl.

get_impl_type()

ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_Proactor::get_impl_type ( )

virtual

Reimplemented in ACE_POSIX_CB_Proactor, and ACE_POSIX_AIOCB_Proactor.

handle_events() [1/2]

virtual int ACE_POSIX_Proactor::handle_events ( )

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.

handle_events() [2/2]

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.

number_of_threads() [1/2]

size_t ACE_POSIX_Proactor::number_of_threads ( ) const

virtual

@ This is a no-op on POSIX platforms. Returns 0.

Implements ACE_Proactor_Impl.

number_of_threads() [2/2]

void ACE_POSIX_Proactor::number_of_threads ( size_t threads )

virtual

Set number of thread used as a parameter to CreatIoCompletionPort.

Implements ACE_Proactor_Impl.

post_completion()

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.

post_wakeup_completions()

int ACE_POSIX_Proactor::post_wakeup_completions ( int how_many )

protectedvirtual

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.

register_handle()

int ACE_POSIX_Proactor::register_handle ( ACE_HANDLE handle, const void * completion_key )

virtual

This function is a no-op function for Unix systems. Returns 0.

Implements ACE_Proactor_Impl.

start_aio()

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

pure virtual

Implemented in ACE_POSIX_AIOCB_Proactor.

wake_up_dispatch_threads()

int ACE_POSIX_Proactor::wake_up_dispatch_threads ( )

virtual

@ This is a no-op on POSIX platforms. Returns 0.

Implements ACE_Proactor_Impl.

Member Data Documentation

os_id_

int ACE_POSIX_Proactor::os_id_

protected

pseudo_task_

ACE_Asynch_Pseudo_Task ACE_POSIX_Proactor::pseudo_task_

private

Task to process pseudo-asynchronous accept/connect.

wakeup_handler_

ACE_Handler ACE_POSIX_Proactor::wakeup_handler_

protected

Handler to handle the wakeups. This works in conjunction with the <ACE_Proactor::run_event_loop>.

---

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

• POSIX_Proactor.h
• POSIX_Proactor.cpp
• POSIX_Proactor.inl