Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_Proactor Class Reference

A manager for asynchronous event demultiplexing. More...

`#include <Proactor.h>`

Collaboration diagram for ACE_Proactor:

[legend]
List of all members.

## Public Types
typedef ACE_Timer_Queue_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_QUEUE
| Public type.
## Public Methods
| ACE_Proactor (ACE_Proactor_Impl *implementation = 0, int delete_implementation = 0, TIMER_QUEUE *tq = 0)
virtual | ~ACE_Proactor (void)
| Virtual destruction.
virtual int | close (void)
| Close the IO completion port.
virtual int | register_handle (ACE_HANDLE handle, const void *completion_key)
| This method adds the <handle> to the I/O completion port. This function is a no-op function for Unix systems and returns 0;.
virtual long | schedule_timer (ACE_Handler &handler, const void *act, const ACE_Time_Value &time)
virtual long | schedule_repeating_timer (ACE_Handler &handler, const void *act, const ACE_Time_Value &interval)
virtual long | schedule_timer (ACE_Handler &handler, const void *act, const ACE_Time_Value &time, const ACE_Time_Value &interval)
| This combines the above two methods into one. Mostly for backward compatibility.
virtual int | cancel_timer (ACE_Handler &handler, int dont_call_handle_close = 1)
| Cancel all timers associated with this <handler>. Returns number of timers cancelled.
virtual int | cancel_timer (long timer_id, const void **act = 0, int dont_call_handle_close = 1)
virtual int | handle_events (ACE_Time_Value &wait_time)
virtual int | handle_events (void)
int | wake_up_dispatch_threads (void)
| Add wakeup dispatch threads (reinit).
int | close_dispatch_threads (int wait)
| Close all dispatch threads.
size_t | number_of_threads (void) const
| Number of thread used as a parameter to CreatIoCompletionPort.
void | number_of_threads (size_t threads)
TIMER_QUEUE* | timer_queue (void) const
| Get/Set timer queue.
void | timer_queue (TIMER_QUEUE *timer_queue)
virtual ACE_HANDLE | get_handle (void) const
virtual ACE_Proactor_Impl* | implementation (void) const
| Get the implementation class.
virtual ACE_Asynch_Read_Stream_Impl* | create_asynch_read_stream (void)
| Create the correct implementation class for doing Asynch_Read_Stream.
virtual ACE_Asynch_Write_Stream_Impl* | create_asynch_write_stream (void)
| Create the correct implementation class for doing Asynch_Write_Stream.
virtual ACE_Asynch_Read_File_Impl* | create_asynch_read_file (void)
| Create the correct implementation class for doing Asynch_Read_File.
virtual ACE_Asynch_Write_File_Impl* | create_asynch_write_file (void)
| Create the correct implementation class for doing Asynch_Write_File.
virtual ACE_Asynch_Accept_Impl* | create_asynch_accept (void)
| Create the correct implementation class for doing Asynch_Accept.
virtual ACE_Asynch_Transmit_File_Impl* | create_asynch_transmit_file (void)
| Create the correct implementation class for doing Asynch_Transmit_File.
virtual ACE_Asynch_Read_Dgram_Impl* | create_asynch_read_dgram (void)
| Create the correct implementation class for doing Asynch_Read_Dgram.
virtual ACE_Asynch_Write_Dgram_Impl* | create_asynch_write_dgram (void)
| Create the correct implementation class for doing Asynch_Write_Dgram.
virtual ACE_Asynch_Read_Stream_Result_Impl* | create_asynch_read_stream_result (ACE_Handler &handler, ACE_HANDLE handle, ACE_Message_Block &message_block, u_long 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_Result_Impl* | create_asynch_write_stream_result (ACE_Handler &handler, ACE_HANDLE handle, ACE_Message_Block &message_block, u_long 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_Result_Impl* | create_asynch_read_file_result (ACE_Handler &handler, ACE_HANDLE handle, ACE_Message_Block &message_block, u_long 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_Result_Impl* | create_asynch_write_file_result (ACE_Handler &handler, ACE_HANDLE handle, ACE_Message_Block &message_block, u_long 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_Result_Impl* | create_asynch_read_dgram_result (ACE_Handler &handler, 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_Result_Impl* | create_asynch_write_dgram_result (ACE_Handler &handler, 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_Result_Impl* | create_asynch_accept_result (ACE_Handler &handler, ACE_HANDLE listen_handle, ACE_HANDLE accept_handle, ACE_Message_Block &message_block, u_long 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_Transmit_File_Result_Impl* | create_asynch_transmit_file_result (ACE_Handler &handler, ACE_HANDLE socket, ACE_HANDLE file, ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer, u_long bytes_to_write, u_long offset, u_long offset_high, u_long 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 (ACE_Handler &handler, const void *act, const ACE_Time_Value &tv, ACE_HANDLE event = ACE_INVALID_HANDLE, int priority = 0, int signal_number = ACE_SIGRTMIN)
## Static Public Methods
ACE_Proactor* | instance (size_t threads = 0)
| Get pointer to a process-wide . <threads> should be part of another method.
ACE_Proactor* | instance (ACE_Proactor *)
| Set pointer to a process-wide and return existing pointer.
void | close_singleton (void)
| Delete the dynamically allocated Singleton.
void | cleanup (void *instance, void *arg)
| Cleanup method, used by the to destroy the singleton.
int | run_event_loop (void)
| Run the event loop until the method returns -1 or the <end_event_loop> method is invoked.
int | run_event_loop (ACE_Time_Value &tv)
int | end_event_loop (void)
int | reset_event_loop (void)
int | event_loop_done (void)
| Report if the event loop is finished.
## Protected Methods
virtual void | implementation (ACE_Proactor_Impl *implementation)
| Set the implementation class.
## Protected Attributes
ACE_Proactor_Impl* | implementation_
| Delegation/implementation class that all methods will be forwarded to.
int | delete_implementation_
| Flag used to indicate whether we are responsible for cleaning up the implementation instance.
ACE_Proactor_Timer_Handler* | timer_handler_
| Handles timeout events.
ACE_Thread_Manager | thr_mgr_
| This will manage the thread in the Timer_Handler.
TIMER_QUEUE* | timer_queue_
| Timer Queue.
int | delete_timer_queue_
| Flag on whether to delete the timer queue.
## Static Protected Methods
int | post_wakeup_completions (int how_many)
## Static Protected Attributes
ACE_Proactor* | proactor_ = 0
| Pointer to a process-wide .
int | delete_proactor_ = 0
| Must delete the <proactor_> if non-0.
sig_atomic_t | end_event_loop_ = 0
| Terminate the proactor event loop.
sig_atomic_t | event_loop_thread_count_ = 0
| Number of threads in the event loop.
## Private Types
typedef ACE_Timer_Queue_Iterator_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_QUEUE_ITERATOR
typedef ACE_Timer_List_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_LIST
typedef ACE_Timer_List_Iterator_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_LIST_ITERATOR
typedef ACE_Timer_Heap_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_HEAP
typedef ACE_Timer_Heap_Iterator_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_HEAP_ITERATOR
typedef ACE_Timer_Wheel_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_WHEEL
typedef ACE_Timer_Wheel_Iterator_T< ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> | TIMER_WHEEL_ITERATOR
## Private Methods
| ACE_Proactor (const ACE_Proactor &)
| Deny access since member-wise won't work...
ACE_Proactor& | operator= (const ACE_Proactor &)
## Friends
class | ACE_Proactor_Timer_Handler

## Detailed Description

A manager for asynchronous event demultiplexing.

See the Proactor pattern description at http://www.cs.wustl.edu/~schmidt/proactor.ps.gz for more details.

## Member Typedef Documentation

typedef ACE_Timer_Heap_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_HEAP`[private]`

typedef ACE_Timer_Heap_Iterator_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_HEAP_ITERATOR`[private]`

typedef ACE_Timer_List_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_LIST`[private]`

typedef ACE_Timer_List_Iterator_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_LIST_ITERATOR`[private]`

typedef ACE_Timer_Queue_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_QUEUE

| Public type.

typedef ACE_Timer_Queue_Iterator_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_QUEUE_ITERATOR`[private]`

typedef ACE_Timer_Wheel_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_WHEEL`[private]`

typedef ACE_Timer_Wheel_Iterator_T<ACE_Handler *, ACE_Proactor_Handle_Timeout_Upcall, ACE_SYNCH_RECURSIVE_MUTEX> ACE_Proactor::TIMER_WHEEL_ITERATOR`[private]`

## Constructor & Destructor Documentation

ACE_Proactor::ACE_Proactor ( | ACE_Proactor_Impl * implementation = 0,
| int delete_implementation = 0,
| TIMER_QUEUE * tq = 0 )

| Constructor. If <implementation> is 0, the correct implementation object will be created. <delete_implementation> flag determines whether the implementation object should be deleted by the Proactor or not. If <tq> is 0, a new TIMER_QUEUE is created.

ACE_Proactor::~ACE_Proactor ( | void )`[virtual]`

| Virtual destruction.

ACE_Proactor::ACE_Proactor ( | const ACE_Proactor & )`[private]`

| Deny access since member-wise won't work...

## Member Function Documentation

int ACE_Proactor::cancel_timer ( | long timer_id,
| const void ** act = 0,
| int dont_call_handle_close = 1 )`[virtual]`

| Cancel the single that matches the <timer_id> value (which was returned from the <schedule> method). If is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the <Handler> was registered. This makes it possible to free up the memory and avoid memory leaks. Returns 1 if cancellation succeeded and 0 if the <timer_id> wasn't found.

int ACE_Proactor::cancel_timer ( | ACE_Handler & handler,
| int dont_call_handle_close = 1 )`[virtual]`

| Cancel all timers associated with this <handler>. Returns number of timers cancelled.

void ACE_Proactor::cleanup ( | void * instance,
| void * arg )`[inline, static]`

| Cleanup method, used by the to destroy the singleton.

int ACE_Proactor::close ( | void )`[virtual]`

| Close the IO completion port.

int ACE_Proactor::close_dispatch_threads ( | int wait )

| Close all dispatch threads.

void ACE_Proactor::close_singleton ( | void )`[static]`

| Delete the dynamically allocated Singleton.

ACE_Asynch_Accept_Impl * ACE_Proactor::create_asynch_accept ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Accept.

ACE_Asynch_Accept_Result_Impl * ACE_Proactor::create_asynch_accept_result ( | ACE_Handler & handler,
| ACE_HANDLE listen_handle,
| ACE_HANDLE accept_handle,
| ACE_Message_Block & message_block,
| u_long 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.

ACE_Asynch_Read_Dgram_Impl * ACE_Proactor::create_asynch_read_dgram ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Read_Dgram.

ACE_Asynch_Read_Dgram_Result_Impl * ACE_Proactor::create_asynch_read_dgram_result ( | ACE_Handler & handler,
| 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.

ACE_Asynch_Read_File_Impl * ACE_Proactor::create_asynch_read_file ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Read_File.

ACE_Asynch_Read_File_Result_Impl * ACE_Proactor::create_asynch_read_file_result ( | ACE_Handler & handler,
| ACE_HANDLE handle,
| ACE_Message_Block & message_block,
| u_long 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.

ACE_Asynch_Read_Stream_Impl * ACE_Proactor::create_asynch_read_stream ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Read_Stream.

ACE_Asynch_Read_Stream_Result_Impl * ACE_Proactor::create_asynch_read_stream_result ( | ACE_Handler & handler,
| ACE_HANDLE handle,
| ACE_Message_Block & message_block,
| u_long 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.

ACE_Asynch_Result_Impl * ACE_Proactor::create_asynch_timer ( | ACE_Handler & handler,
| 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. If <signal_number> is -1, <POSIX_SIG_Proactor> will create a Timer object with a meaningful signal number, choosing the largest signal number from the signal mask of the Proactor.

ACE_Asynch_Transmit_File_Impl * ACE_Proactor::create_asynch_transmit_file ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Transmit_File.

ACE_Asynch_Transmit_File_Result_Impl * ACE_Proactor::create_asynch_transmit_file_result ( | ACE_Handler & handler,
| ACE_HANDLE socket,
| ACE_HANDLE file,
| ACE_Asynch_Transmit_File::Header_And_Trailer * header_and_trailer,
| u_long bytes_to_write,
| u_long offset,
| u_long offset_high,
| u_long 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.

ACE_Asynch_Write_Dgram_Impl * ACE_Proactor::create_asynch_write_dgram ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Write_Dgram.

ACE_Asynch_Write_Dgram_Result_Impl * ACE_Proactor::create_asynch_write_dgram_result ( | ACE_Handler & handler,
| 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.

ACE_Asynch_Write_File_Impl * ACE_Proactor::create_asynch_write_file ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Write_File.

ACE_Asynch_Write_File_Result_Impl * ACE_Proactor::create_asynch_write_file_result ( | ACE_Handler & handler,
| ACE_HANDLE handle,
| ACE_Message_Block & message_block,
| u_long 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.

ACE_Asynch_Write_Stream_Impl * ACE_Proactor::create_asynch_write_stream ( | void )`[virtual]`

| Create the correct implementation class for doing Asynch_Write_Stream.

ACE_Asynch_Write_Stream_Result_Impl * ACE_Proactor::create_asynch_write_stream_result ( | ACE_Handler & handler,
| ACE_HANDLE handle,
| ACE_Message_Block & message_block,
| u_long 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.

int ACE_Proactor::end_event_loop ( | void )`[static]`

| Instruct the to terminate its event loop. This method wakes up all the threads blocked on waiting for completions and end the event loop.

int ACE_Proactor::event_loop_done ( | void )`[static]`

| Report if the event loop is finished.

ACE_HANDLE ACE_Proactor::get_handle ( | void ) const`[virtual]`

| Get the event handle. It is a no-op in POSIX platforms and it returns ACE_INVALID_HANDLE.

int ACE_Proactor::handle_events ( | void )`[virtual]`

| Block indefinitely until at least one event is dispatched. Returns: Returns 1 when a completion is dispatched. On error, returns -1 and sets errno accordingly.

int ACE_Proactor::handle_events ( | ACE_Time_Value & wait_time )`[virtual]`

  | Dispatch a single set of events, waiting up to a specified time limit if necessary. Parameters:
  wait_time | the time to wait for an event to occur. This is a relative time. On successful return, the time is updated to reflect the amount of time spent waiting for event(s) to occur.
Returns: Returns 0 if no events occur before the wait_time expires. Returns 1 when a completion is dispatched. On error, returns -1 and sets errno accordingly.

void ACE_Proactor::implementation ( | ACE_Proactor_Impl * implementation )`[protected, virtual]`

| Set the implementation class.

ACE_Proactor_Impl * ACE_Proactor::implementation ( | void ) const`[virtual]`

| Get the implementation class.

ACE_Proactor * ACE_Proactor::instance ( | ACE_Proactor * r )`[static]`

| Set pointer to a process-wide and return existing pointer.

ACE_Proactor * ACE_Proactor::instance ( | size_t threads = 0 )`[static]`

| Get pointer to a process-wide . <threads> should be part of another method.

void ACE_Proactor::number_of_threads ( | size_t threads )

size_t ACE_Proactor::number_of_threads ( | void ) const

| Number of thread used as a parameter to CreatIoCompletionPort.

ACE_Proactor& ACE_Proactor::operator= ( | const ACE_Proactor & )`[private]`

int ACE_Proactor::post_wakeup_completions ( | int how_many )`[static, protected]`

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

int ACE_Proactor::register_handle ( | ACE_HANDLE handle,
| const void * completion_key )`[virtual]`

| This method adds the <handle> to the I/O completion port. This function is a no-op function for Unix systems and returns 0;.

int ACE_Proactor::reset_event_loop ( | void )`[static]`

| Resets the static so that the <run_event_loop> method can be restarted.

int ACE_Proactor::run_event_loop ( | ACE_Time_Value & tv )`[static]`

| Run the event loop until the method returns -1, the <end_event_loop> method is invoked, or the expires.

int ACE_Proactor::run_event_loop ( | void )`[static]`

| Run the event loop until the method returns -1 or the <end_event_loop> method is invoked.

long ACE_Proactor::schedule_repeating_timer ( | ACE_Handler & handler,
| const void * act,
| const ACE_Time_Value & interval )`[virtual]`

long ACE_Proactor::schedule_timer ( | ACE_Handler & handler,
| const void * act,
| const ACE_Time_Value & time,
| const ACE_Time_Value & interval )`[virtual]`

| This combines the above two methods into one. Mostly for backward compatibility.

long ACE_Proactor::schedule_timer ( | ACE_Handler & handler,
| const void * act,
| const ACE_Time_Value & time )`[virtual]`

| Schedule a <handler> that will expire after <time>. If it expires then is passed in as the value to the <handler>'s <handle_timeout> callback method. This method returns a <timer_id>. This <timer_id> can be used to cancel a timer before it expires. The cancellation ensures that <timer_ids> are unique up to values of greater than 2 billion timers. As long as timers don't stay around longer than this there should be no problems with accidentally deleting the wrong timer. Returns -1 on failure (which is guaranteed never to be a valid <timer_id>).

void ACE_Proactor::timer_queue ( | TIMER_QUEUE * tq )

TIMER_QUEUE * ACE_Proactor::timer_queue ( | void ) const

| Get/Set timer queue.

int ACE_Proactor::wake_up_dispatch_threads ( | void )

| Add wakeup dispatch threads (reinit).

## Friends And Related Function Documentation

class ACE_Proactor_Timer_Handler`[friend]`

| Timer handler runs a thread and manages the timers, on behalf of the Proactor.

## Member Data Documentation

int ACE_Proactor::delete_implementation_`[protected]`

| Flag used to indicate whether we are responsible for cleaning up the implementation instance.

int ACE_Proactor::delete_proactor_ = 0`[static, protected]`

| Must delete the <proactor_> if non-0.

int ACE_Proactor::delete_timer_queue_`[protected]`

| Flag on whether to delete the timer queue.

sig_atomic_t ACE_Proactor::end_event_loop_ = 0`[static, protected]`

| Terminate the proactor event loop.

sig_atomic_t ACE_Proactor::event_loop_thread_count_ = 0`[static, protected]`

| Number of threads in the event loop.

ACE_Proactor_Impl * ACE_Proactor::implementation_`[protected]`

| Delegation/implementation class that all methods will be forwarded to.

ACE_Proactor * ACE_Proactor::proactor_ = 0`[static, protected]`

| Pointer to a process-wide .

ACE_Thread_Manager ACE_Proactor::thr_mgr_`[protected]`

| This will manage the thread in the Timer_Handler.

ACE_Proactor_Timer_Handler * ACE_Proactor::timer_handler_`[protected]`

| Handles timeout events.

TIMER_QUEUE * ACE_Proactor::timer_queue_`[protected]`

| Timer Queue.

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

- Proactor.h
- Proactor.cpp