ACE_Reactor Class Reference

The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., <ACE_Select_Reactor> or <ACE_WFMO_Reactor>. More...

#include <Reactor.h>

Inheritance diagram for ACE_Reactor:

Inheritance graph
[legend]
Collaboration diagram for ACE_Reactor:

Collaboration graph
[legend]
List of all members.

Public Types

typedef int(* REACTOR_EVENT_HOOK )(ACE_Reactor *)
enum  { GET_MASK = 1, SET_MASK = 2, ADD_MASK = 3, CLR_MASK = 4 }
 Operations on the "ready" mask and the "dispatch" mask. More...

Public Member Functions

virtual int run_reactor_event_loop (REACTOR_EVENT_HOOK=0)
virtual int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK=0)
virtual int run_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK=0)
virtual int run_alertable_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK=0)
virtual int end_reactor_event_loop (void)
virtual int reactor_event_loop_done (void)
 Indicate if the Reactor's event loop has been ended.
virtual void reset_reactor_event_loop (void)
 ACE_Reactor (ACE_Reactor_Impl *implementation=0, int delete_implementation=0)
virtual ~ACE_Reactor (void)
 Close down and release all resources.
virtual int open (size_t max_number_of_handles, int restart=0, ACE_Sig_Handler *signal_handler=0, ACE_Timer_Queue *timer_queue=0)
virtual int set_sig_handler (ACE_Sig_Handler *signal_handler)
 Use a user specified signal handler instead.
virtual int timer_queue (ACE_Timer_Queue *tq)
 Set a user-specified timer queue.
virtual ACE_Timer_Queuetimer_queue (void) const
 Return the current <ACE_Timer_Queue>.
virtual int close (void)
 Close down and release all resources.
virtual int work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
virtual int handle_events (ACE_Time_Value *max_wait_time=0)
virtual int alertable_handle_events (ACE_Time_Value *max_wait_time=0)
virtual int handle_events (ACE_Time_Value &max_wait_time)
virtual int alertable_handle_events (ACE_Time_Value &max_wait_time)
virtual int register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)
virtual int register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks)
virtual int register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0)
virtual int register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *event_handler, ACE_Sig_Action *sig_action=0)
virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask masks)
virtual int remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks)
virtual int remove_handler (const ACE_Handle_Set &handles, ACE_Reactor_Mask masks)
virtual int remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=0, int sigkey=-1)
virtual int remove_handler (const ACE_Sig_Set &sigset)
virtual int suspend_handler (ACE_HANDLE handle)
virtual int suspend_handler (ACE_Event_Handler *event_handler)
virtual int suspend_handler (const ACE_Handle_Set &handles)
virtual int suspend_handlers (void)
virtual int resume_handler (ACE_HANDLE handle)
virtual int resume_handler (ACE_Event_Handler *event_handler)
virtual int resume_handler (const ACE_Handle_Set &handles)
virtual int resume_handlers (void)
virtual int resumable_handler (void)
virtual long schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval=ACE_Time_Value::zero)
virtual int reset_timer_interval (long timer_id, const ACE_Time_Value &interval)
virtual int cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1)
virtual int cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1)
virtual int schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added)
virtual int schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added)
virtual int cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared)
virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared)
virtual int notify (ACE_Event_Handler *event_handler=0, ACE_Reactor_Mask masks=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *timeout=0)
virtual void max_notify_iterations (int iterations)
virtual int max_notify_iterations (void)
virtual int purge_pending_notifications (ACE_Event_Handler *, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual ACE_Event_Handlerfind_handler (ACE_HANDLE handle)
virtual int handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
virtual int handler (int signum, ACE_Event_Handler **event_handler=0)
virtual int initialized (void)
virtual size_t size (void) const
virtual ACE_Locklock (void)
 Returns a reference to the Reactor's internal lock.
virtual void wakeup_all_threads (void)
 Wake up all threads in waiting in the event loop.
virtual int owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0)
 Transfers ownership of Reactor to the <new_owner>.
virtual int owner (ACE_thread_t *owner)
 Return the ID of the "owner" thread.
virtual void requeue_position (int position)
 Set position of the owner thread.
virtual int requeue_position (void)
 Get position of the owner thread.
virtual int restart (void)
 Get the existing restart value.
virtual int restart (int r)
 Set a new value for restart and return the original value.
virtual int mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
virtual int mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
virtual int ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
virtual int ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
 GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
virtual ACE_Reactor_Implimplementation (void) const
 Get the implementation class.
virtual int current_info (ACE_HANDLE handle, size_t &msg_size)
virtual int uses_event_associations (void)
void dump (void) const
 Dump the state of the object.

Static Public Member Functions

static ACE_Reactorinstance (void)
 Get pointer to a process-wide <ACE_Reactor>.
static ACE_Reactorinstance (ACE_Reactor *, int delete_reactor=0)
static void close_singleton (void)
 Delete the dynamically allocated Singleton.
static const ACE_TCHARdll_name (void)
 Name of the dll in which the dll lives.
static const ACE_TCHARname (void)
 Name of the component--ACE_Reactor in this case.
static int run_event_loop (void)
static int run_alertable_event_loop (void)
static int run_event_loop (ACE_Time_Value &tv)
static int run_alertable_event_loop (ACE_Time_Value &tv)
static int end_event_loop (void)
static int event_loop_done (void)
static void reset_event_loop (void)
static int check_reconfiguration (ACE_Reactor *)

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.

Protected Member Functions

virtual void implementation (ACE_Reactor_Impl *implementation)
 Set the implementation class.
 ACE_Reactor (const ACE_Reactor &)
 Deny access since member-wise won't work...
ACE_Reactoroperator= (const ACE_Reactor &)

Protected Attributes

ACE_Reactor_Implimplementation_
int delete_implementation_

Static Protected Attributes

static ACE_Reactorreactor_ = 0
 Pointer to a process-wide <ACE_Reactor> singleton.
static int delete_reactor_ = 0
 Must delete the <reactor_> singleton if non-0.

Detailed Description

The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., <ACE_Select_Reactor> or <ACE_WFMO_Reactor>.


Member Typedef Documentation

typedef int(* ACE_Reactor::REACTOR_EVENT_HOOK)(ACE_Reactor *)
 

You can add a hook to various run_event methods and the hook will be called after handling every reactor event. If this function returns 0, <run_reactor_event_loop> will check for the return value of <handle_event>. If it is -1, the <run_reactor_event_loop> will return (pre-maturely.)


Member Enumeration Documentation

anonymous enum
 

Operations on the "ready" mask and the "dispatch" mask.

Enumerator:
GET_MASK  Retrieve current value of the the "ready" mask or the "dispatch" mask.
SET_MASK  Set value of bits to new mask (changes the entire mask).
ADD_MASK  Bitwise "or" the value into the mask (only changes enabled bits).
CLR_MASK  Bitwise "and" the negation of the value out of the mask (only changes enabled bits).


Constructor & Destructor Documentation

ACE_Reactor::ACE_Reactor ACE_Reactor_Impl implementation = 0,
int  delete_implementation = 0
 

Create the Reactor using <implementation>. The flag <delete_implementation> tells the Reactor whether or not to delete the <implementation> on destruction.

ACE_Reactor::~ACE_Reactor void   )  [virtual]
 

Close down and release all resources.

Any notifications that remain queued on this reactor instance are lost.

ACE_Reactor::ACE_Reactor const ACE_Reactor  )  [protected]
 

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


Member Function Documentation

ACE_INLINE int ACE_Reactor::alertable_handle_events ACE_Time_Value max_wait_time  )  [virtual]
 

ACE_INLINE int ACE_Reactor::alertable_handle_events ACE_Time_Value max_wait_time = 0  )  [virtual]
 

ACE_INLINE int ACE_Reactor::cancel_timer ACE_Event_Handler event_handler,
int  dont_call_handle_close = 1
[virtual]
 

Cancel all timers associated with event handler.

Shorthand for calling cancel_timer(long,const void **,int) multiple times for all timer associated with <event_handler>.

ACE_Event_Handler::handle_close() will be called with <ACE_Event_Handler::TIMER_MASK> only once irrespective of the number of timers associated with the event handler. ACE_Event_Handler::remove_reference() will also be called once for every timer associated with the event handler.

Returns number of handlers cancelled.

Implements ACE_Reactor_Timer_Interface.

ACE_INLINE int ACE_Reactor::cancel_timer long  timer_id,
const void **  arg = 0,
int  dont_call_handle_close = 1
[virtual]
 

Cancel timer.

Cancel timer associated with <timer_id> that was returned from the schedule_timer() method. If arg 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.

On successful cancellation, ACE_Event_Handler::handle_close() will be called with <ACE_Event_Handler::TIMER_MASK>. ACE_Event_Handler::remove_reference() will also be called.

Implements ACE_Reactor_Timer_Interface.

ACE_INLINE int ACE_Reactor::cancel_wakeup ACE_HANDLE  handle,
ACE_Reactor_Mask  masks_to_be_cleared
[virtual]
 

Clear <masks_to_be_cleared> from the <handle>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

ACE_INLINE int ACE_Reactor::cancel_wakeup ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks_to_be_cleared
[virtual]
 

Clear <masks_to_be_cleared> from the <event_handler>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

int ACE_Reactor::check_reconfiguration ACE_Reactor  )  [static]
 

The singleton reactor is used by the <ACE_Service_Config>. Therefore, we must check for the reconfiguration request and handle it after handling an event.

ACE_INLINE int ACE_Reactor::close void   )  [virtual]
 

Close down and release all resources.

void ACE_Reactor::close_singleton void   )  [static]
 

Delete the dynamically allocated Singleton.

ACE_INLINE int ACE_Reactor::current_info ACE_HANDLE  handle,
size_t &  msg_size
[virtual]
 

Returns 0, if the size of the current message has been put in <size> returns -1, if not. ACE_HANDLE allows the reactor to check if the caller is valid. Used for CLASSIX Reactor implementation.

const ACE_TCHAR * ACE_Reactor::dll_name void   )  [static]
 

Name of the dll in which the dll lives.

void ACE_Reactor::dump void   )  const
 

Dump the state of the object.

ACE_INLINE int ACE_Reactor::end_event_loop void   )  [static]
 

Instruct the <ACE_Reactor::instance> to terminate its event loop and notifies the <ACE_Reactor::instance> so that it can wake up and close down gracefully. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to terminate another reactor, use <ACE_Reactor::end_reactor_event_loop>.

Deprecated:
Use ACE_Reactor::instance()->end_reactor_event_loop() instead

int ACE_Reactor::end_reactor_event_loop void   )  [virtual]
 

Instruct the Reactor to terminate its event loop and notifies the Reactor so that it can wake up and deactivate itself. Deactivating the Reactor would allow the Reactor to be shutdown gracefully. Internally the Reactor calls deactivate () on the underlying implementation. Any queued notifications remain queued on return from this method. If the event loop is restarted in the future, the notifications will be dispatched then. If the reactor is closed or deleted without further dispatching, the notifications will be lost.

ACE_INLINE int ACE_Reactor::event_loop_done void   )  [static]
 

Report if the <ACE_Reactor::instance>'s event loop is finished. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to check another reactor use <ACE_Reactor::reactor_event_loop_done>.

Deprecated:
Use ACE_Reactor::instance()->reactor_event_loop_done() instead

ACE_INLINE ACE_Event_Handler * ACE_Reactor::find_handler ACE_HANDLE  handle  )  [virtual]
 

Return the Event_Handler associated with <handle>. Return 0 if <handle> is not registered.

Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it.

ACE_INLINE int ACE_Reactor::handle_events ACE_Time_Value max_wait_time  )  [virtual]
 

This method is just like the one above, except the <max_wait_time> value is a reference and can therefore never be NULL.

The only difference between <alertable_handle_events> and <handle_events> is that in the alertable case, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

ACE_INLINE int ACE_Reactor::handle_events ACE_Time_Value max_wait_time = 0  )  [virtual]
 

This event loop driver blocks for up to <max_wait_time> before returning. It will return earlier if events occur. Note that <max_wait_time> can be 0, in which case this method blocks indefinitely until events occur.

<max_wait_time> is decremented to reflect how much time this call took. For instance, if a time value of 3 seconds is passed to handle_events and an event occurs after 2 seconds, <max_wait_time> will equal 1 second. This can be used if an application wishes to handle events for some fixed amount of time.

Returns the total number of timers and I/O <ACE_Event_Handler>s that were dispatched, 0 if the <max_wait_time> elapsed without dispatching any handlers, or -1 if an error occurs.

The only difference between <alertable_handle_events> and <handle_events> is that in the alertable case, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

ACE_INLINE int ACE_Reactor::handler int  signum,
ACE_Event_Handler **  event_handler = 0
[virtual]
 

Check to see if <signum> is associated with a valid Event_Handler bound to a signal. Return the <event_handler> associated with this <handler> if <event_handler> != 0.

ACE_INLINE int ACE_Reactor::handler ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Event_Handler **  event_handler = 0
[virtual]
 

Check to see if <handle> is associated with a valid Event_Handler bound to <mask>. Return the <event_handler> associated with this <handler> if <event_handler> != 0.

Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it if <event_handler> != 0.

ACE_INLINE void ACE_Reactor::implementation ACE_Reactor_Impl implementation  )  [protected, virtual]
 

Set the implementation class.

ACE_INLINE ACE_Reactor_Impl * ACE_Reactor::implementation void   )  const [virtual]
 

Get the implementation class.

ACE_INLINE int ACE_Reactor::initialized void   )  [virtual]
 

Returns true if Reactor has been successfully initialized, else false.

ACE_Reactor * ACE_Reactor::instance ACE_Reactor ,
int  delete_reactor = 0
[static]
 

Set pointer to a process-wide <ACE_Reactor> and return existing pointer. If <delete_reactor> != 0 then we'll delete the Reactor at destruction time.

ACE_Reactor * ACE_Reactor::instance void   )  [static]
 

Get pointer to a process-wide <ACE_Reactor>.

ACE_INLINE ACE_Lock & ACE_Reactor::lock void   )  [virtual]
 

Returns a reference to the Reactor's internal lock.

ACE_INLINE int ACE_Reactor::mask_ops ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle> and <mask>.

ACE_INLINE int ACE_Reactor::mask_ops ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the dispatch mask "bit" bound with the <event_handler> and <mask>.

ACE_INLINE int ACE_Reactor::max_notify_iterations void   )  [virtual]
 

Get the maximum number of times that the ACE_Reactor will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop.

ACE_INLINE void ACE_Reactor::max_notify_iterations int  iterations  )  [virtual]
 

Set the maximum number of times that ACE_Reactor will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. By default, this is set to -1, which means "iterate until the queue is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead.

const ACE_TCHAR * ACE_Reactor::name void   )  [static]
 

Name of the component--ACE_Reactor in this case.

ACE_INLINE int ACE_Reactor::notify ACE_Event_Handler event_handler = 0,
ACE_Reactor_Mask  masks = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value timeout = 0
[virtual]
 

Dispatch user specified events.

Handler will be dispatched irrespective of whether it is registered, not registered, or suspended in the Reactor.

If user specified event is successfully queued, ACE_Event_Handler::add_reference() will be called. After the notify occurs and the upcall to the handler completes, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called. No other upcall reference counting is done.

For I/O or OS events, the upcall is invoked with an ACE_INVALID_HANDLE.

For timer events, the upcall is invoked with a null ACT.

Parameters:
event_handler,: IN - Handler on which the event will be dispatched.
masks,: IN - Events to be dispatched - multiple events can be OR'd together.
timeout,: INOUT - Relative time up to which to wait for user specified event to be queued. If tv is 0, wait indefinitely. When the call returns, tv has the time remaining after the call completes.

ACE_INLINE int ACE_Reactor::open size_t  max_number_of_handles,
int  restart = 0,
ACE_Sig_Handler signal_handler = 0,
ACE_Timer_Queue timer_queue = 0
[virtual]
 

Initialize the <ACE_Reactor> to manage <max_number_of_handles>. If <restart> is non-0 then the <ACE_Reactor>'s <handle_events> method will be restarted automatically when <EINTR> occurs. If <signal_handler> or <timer_queue> are non-0 they are used as the signal handler and timer queue, respectively.

ACE_Reactor& ACE_Reactor::operator= const ACE_Reactor  )  [protected]
 

ACE_INLINE int ACE_Reactor::owner ACE_thread_t owner  )  [virtual]
 

Return the ID of the "owner" thread.

ACE_INLINE int ACE_Reactor::owner ACE_thread_t  new_owner,
ACE_thread_t old_owner = 0
[virtual]
 

Transfers ownership of Reactor to the <new_owner>.

ACE_INLINE int ACE_Reactor::purge_pending_notifications ACE_Event_Handler ,
ACE_Reactor_Mask  = ACE_Event_Handler::ALL_EVENTS_MASK
[virtual]
 

Purge any notifications pending in this reactor for the specified <ACE_Event_Handler> object. If <eh> == 0, all notifications for all handlers are removed (but not any notifications posted just to wake up the reactor itself). Returns the number of notifications purged. Returns -1 on error.

After the purging occurs, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.

ACE_INLINE int ACE_Reactor::reactor_event_loop_done void   )  [virtual]
 

Indicate if the Reactor's event loop has been ended.

ACE_INLINE int ACE_Reactor::ready_ops ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.

ACE_INLINE int ACE_Reactor::ready_ops ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the ready "bit" bound with the <event_handler> and <mask>.

ACE_INLINE int ACE_Reactor::register_handler const ACE_Sig_Set sigset,
ACE_Event_Handler event_handler,
ACE_Sig_Action sig_action = 0
[virtual]
 

Register handler for multiple signals.

Shorthand for calling register_handler(int,ACE_Event_Handler*,ACE_Sig_Action*,ACE_Event_Handler**,ACE_Sig_Action*) multiple times for the same <event_handler> and <sig_action> but different <signals>.

ACE_INLINE int ACE_Reactor::register_handler int  signum,
ACE_Event_Handler new_sh,
ACE_Sig_Action new_disp = 0,
ACE_Event_Handler **  old_sh = 0,
ACE_Sig_Action old_disp = 0
[virtual]
 

Register handler for signals.

Register <new_sh> to handle the signal <signum> using the <new_disp>. Returns the <old_sh> that was previously registered (if any), along with the <old_disp> of the signal handler.

Reactor will call ACE_Event_Handler::add_reference() on <new_sh> and ACE_Event_Handler::remove_reference() on <old_sh>.

ACE_INLINE int ACE_Reactor::register_handler const ACE_Handle_Set handles,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks
[virtual]
 

Register handler for multiple I/O events.

Shorthand for calling register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), multiple times for the same <event_handler> and <masks> but different <handles>.

ACE_INLINE int ACE_Reactor::register_handler ACE_HANDLE  event_handle,
ACE_HANDLE  io_handle,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask
[virtual]
 

Register handler for I/O events.

Similar to register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), except that the user gets to specify the event handle that will be used for this registration. This only applies to Reactors that use event handles for I/O registrations.

ACE_INLINE int ACE_Reactor::register_handler ACE_Event_Handler event_handler,
ACE_HANDLE  event_handle = ACE_INVALID_HANDLE
[virtual]
 

Register handler for OS events.

Register an <event_handler> that will be notified when <event_handle> is signaled.

Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair.

This interface is only available Win32 platforms because ACE_HANDLE is an int on non-Win32 platforms and compilers are not able to tell the difference between register_handler(ACE_Event_Handler*,ACE_Reactor_Mask) and register_handler(ACE_Event_Handler*,ACE_HANDLE).

ACE_INLINE int ACE_Reactor::register_handler ACE_HANDLE  io_handle,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask
[virtual]
 

Register handler for I/O events.

Same as register_handler(ACE_Event_Handler*,ACE_Reactor_Mask), except handle is explicitly specified.

ACE_INLINE int ACE_Reactor::register_handler ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask
[virtual]
 

Register handler for I/O events.

A handler can be associated with multiple handles. A handle cannot be associated with multiple handlers.

The handle will come from ACE_Event_Handler::get_handle().

Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair.

If this handler/handle pair has already been registered, any new masks specified will be added. In this case, ACE_Event_Handler::add_reference() will not be called.

If the registered handler is currently suspended, it will remain suspended. When the handler is resumed, it will have the existing masks plus any masks added through this call. Handlers do not have partial suspensions.

ACE_INLINE int ACE_Reactor::remove_handler const ACE_Sig_Set sigset  )  [virtual]
 

Remove multiple signal handler registrations.

Shorthand for calling remove_handler(int,ACE_Sig_Action*,ACE_Sig_Action*,int) multiple times for every signal in <sigset>.

ACE_INLINE int ACE_Reactor::remove_handler int  signum,
ACE_Sig_Action new_disp,
ACE_Sig_Action old_disp = 0,
int  sigkey = -1
[virtual]
 

Remove signal handler registration.

Remove the ACE_Event_Handler currently associated with <signum>. Install the new disposition (if given) and return the previous disposition (if desired by the caller).

ACE_Event_Handler::handle_close() will be called with <ACE_Event_Handler::SIGNAL_MASK>. ACE_Event_Handler::remove_reference() will also be called.

ACE_INLINE int ACE_Reactor::remove_handler const ACE_Handle_Set handles,
ACE_Reactor_Mask  masks
[virtual]
 

Remove <masks> from multiple <handle> registrations.

Shorthand for calling remove_handler(ACE_HANDLE,ACE_Reactor_Mask) multiple times for the same <masks> but different <handles>.

ACE_INLINE int ACE_Reactor::remove_handler ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks
[virtual]
 

Remove <masks> from <event_handler> registration.

Same as remove_handler(ACE_HANDLE,ACE_Reactor_Mask), except <handle> comes from ACE_Event_Handler::get_handle().

ACE_INLINE int ACE_Reactor::remove_handler ACE_HANDLE  handle,
ACE_Reactor_Mask  masks
[virtual]
 

Remove <masks> from <handle> registration.

For I/O handles, <masks> are removed from the Reactor. Unless <masks> includes <ACE_Event_Handler::DONT_CALL>, ACE_Event_Handler::handle_close() will be called with the <masks> that have been removed. If all masks have been removed, ACE_Event_Handler::remove_reference() will be called.

For OS handles, the <handle> is removed from the Reactor. Unless <masks> includes <ACE_Event_Handler::DONT_CALL>, ACE_Event_Handler::handle_close() will be called with <ACE_Event_Handler::NULL_MASK>. ACE_Event_Handler::remove_reference() will also be called.

ACE_INLINE int ACE_Reactor::requeue_position void   )  [virtual]
 

Get position of the owner thread.

ACE_INLINE void ACE_Reactor::requeue_position int  position  )  [virtual]
 

Set position of the owner thread.

ACE_INLINE void ACE_Reactor::reset_event_loop void   )  [static]
 

Resets the <ACE_Reactor::end_event_loop_> static so that the <run_event_loop> method can be restarted. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to reset another reactor use <ACE_Reactor::reset_reactor_event_loop>.

Deprecated:
Use ACE_Reactor::instance()->reset_reactor_event_loop() instead

void ACE_Reactor::reset_reactor_event_loop void   )  [virtual]
 

Resets the <ACE_Reactor::end_event_loop_> static so that the <run_event_loop> method can be restarted.

ACE_INLINE int ACE_Reactor::reset_timer_interval long  timer_id,
const ACE_Time_Value interval
[virtual]
 

Reset recurring timer interval.

Resets the interval of the timer represented by <timer_id> to <interval>, which is specified in relative time to the current <gettimeofday>. If <interval> is equal to <ACE_Time_Value::zero>, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not.

This change will not take effect until the next timeout.

Implements ACE_Reactor_Timer_Interface.

ACE_INLINE int ACE_Reactor::restart int  r  )  [virtual]
 

Set a new value for restart and return the original value.

ACE_INLINE int ACE_Reactor::restart void   )  [virtual]
 

Get the existing restart value.

int ACE_Reactor::resumable_handler void   )  [virtual]
 

Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. A positive value indicates that the handlers are application resumable. A value of 0 indicates otherwise.

ACE_INLINE int ACE_Reactor::resume_handler const ACE_Handle_Set handles  )  [virtual]
 

Resume <handles>.

Shorthand for calling resume_handler(ACE_HANDLE) with multiple <handles>.

ACE_INLINE int ACE_Reactor::resume_handler ACE_Event_Handler event_handler  )  [virtual]
 

Resume <event_handler>.

Handle is obtained from ACE_Event_Handler::get_handle().

ACE_INLINE int ACE_Reactor::resume_handler ACE_HANDLE  handle  )  [virtual]
 

Resume <handle>.

ACE_INLINE int ACE_Reactor::resume_handlers void   )  [virtual]
 

Resume all registered handles.

ACE_INLINE int ACE_Reactor::run_alertable_event_loop ACE_Time_Value tv  )  [static]
 

ACE_INLINE int ACE_Reactor::run_alertable_event_loop void   )  [static]
 

int ACE_Reactor::run_alertable_reactor_event_loop ACE_Time_Value tv,
REACTOR_EVENT_HOOK  = 0
[virtual]
 

int ACE_Reactor::run_alertable_reactor_event_loop REACTOR_EVENT_HOOK  = 0  )  [virtual]
 

ACE_INLINE int ACE_Reactor::run_event_loop ACE_Time_Value tv  )  [static]
 

Run the event loop until the <ACE_Reactor::handle_events> or <ACE_Reactor::alertable_handle_events> methods returns -1, the <end_event_loop> method is invoked, or the <ACE_Time_Value> expires. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to run another reactor use <ACE_Reactor::run_reactor_event_loop>.

Deprecated:
Use ACE_Reactor::instance()->run_reactor_event_loop() instead

ACE_INLINE int ACE_Reactor::run_event_loop void   )  [static]
 

Run the event loop until the <ACE_Reactor::handle_events/ACE_Reactoralertable_handle_events> method returns -1 or the <end_event_loop> method is invoked. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to run another reactor use <ACE_Reactor::run_reactor_event_loop>.

Deprecated:
Use ACE_Reactor::instance()->run_reactor_event_loop() instead

int ACE_Reactor::run_reactor_event_loop ACE_Time_Value tv,
REACTOR_EVENT_HOOK  = 0
[virtual]
 

Run the event loop until the <ACE_Reactor::handle_events> or <ACE_Reactor::alertable_handle_events> methods returns -1, the <end_reactor_event_loop> method is invoked, or the <ACE_Time_Value> expires.

int ACE_Reactor::run_reactor_event_loop REACTOR_EVENT_HOOK  = 0  )  [virtual]
 

Run the event loop until the <ACE_Reactor::handle_events/ACE_Reactoralertable_handle_events> method returns -1 or the <end_reactor_event_loop> method is invoked.

ACE_INLINE long ACE_Reactor::schedule_timer ACE_Event_Handler event_handler,
const void *  arg,
const ACE_Time_Value delay,
const ACE_Time_Value interval = ACE_Time_Value::zero
[virtual]
 

Schedule a timer event.

Schedule a timer event that will expire after an <delay> amount of time. The return value of this method, a timer_id value, uniquely identifies the <event_handler> in the ACE_Reactor's internal list of timers. This timer_id value can be used to cancel the timer with the cancel_timer() call.

Reactor will call ACE_Event_Handler::add_reference() on the handler. After the timeout occurs and ACE_Event_Handler::handle_timeout() has completed, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.

See also:
cancel_timer()

reset_timer_interval()

Parameters:
event_handler event handler to schedule on reactor
arg argument passed to the handle_timeout() method of event_handler
delay time interval after which the timer will expire
interval time interval after which the timer will be automatically rescheduled
Returns:
-1 on failure, a timer_id value on success

Implements ACE_Reactor_Timer_Interface.

ACE_INLINE int ACE_Reactor::schedule_wakeup ACE_HANDLE  handle,
ACE_Reactor_Mask  masks_to_be_added
[virtual]
 

Add <masks_to_be_added> to the <handle>'s entry. <event_handler> associated with <handle> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

ACE_INLINE int ACE_Reactor::schedule_wakeup ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks_to_be_added
[virtual]
 

Add <masks_to_be_added> to the <event_handler>'s entry. <event_handler> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

ACE_INLINE int ACE_Reactor::set_sig_handler ACE_Sig_Handler signal_handler  )  [virtual]
 

Use a user specified signal handler instead.

ACE_INLINE size_t ACE_Reactor::size void   )  const [virtual]
 

Returns the current size of the Reactor's internal descriptor table.

ACE_INLINE int ACE_Reactor::suspend_handler const ACE_Handle_Set handles  )  [virtual]
 

Suspend <handles> temporarily.

Shorthand for calling suspend_handler(ACE_HANDLE) with multiple <handles>.

ACE_INLINE int ACE_Reactor::suspend_handler ACE_Event_Handler event_handler  )  [virtual]
 

Suspend <event_handler> temporarily.

Handle is obtained from ACE_Event_Handler::get_handle().

ACE_INLINE int ACE_Reactor::suspend_handler ACE_HANDLE  handle  )  [virtual]
 

Suspend <handle> temporarily.

ACE_INLINE int ACE_Reactor::suspend_handlers void   )  [virtual]
 

Suspend all registered handles temporarily.

ACE_INLINE ACE_Timer_Queue * ACE_Reactor::timer_queue void   )  const [virtual]
 

Return the current <ACE_Timer_Queue>.

ACE_INLINE int ACE_Reactor::timer_queue ACE_Timer_Queue tq  )  [virtual]
 

Set a user-specified timer queue.

ACE_INLINE int ACE_Reactor::uses_event_associations void   )  [virtual]
 

Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise.

ACE_INLINE void ACE_Reactor::wakeup_all_threads void   )  [virtual]
 

Wake up all threads in waiting in the event loop.

ACE_INLINE int ACE_Reactor::work_pending const ACE_Time_Value max_wait_time = ACE_Time_Value::zero  )  [virtual]
 

Returns non-zero if there are I/O events "ready" for dispatching, but does not actually dispatch the event handlers. By default, don't block while checking this, i.e., "poll".


Member Data Documentation

ACE_Reactor::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

int ACE_Reactor::delete_implementation_ [protected]
 

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

int ACE_Reactor::delete_reactor_ = 0 [static, protected]
 

Must delete the <reactor_> singleton if non-0.

ACE_Reactor_Impl* ACE_Reactor::implementation_ [protected]
 

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

ACE_Reactor * ACE_Reactor::reactor_ = 0 [static, protected]
 

Pointer to a process-wide <ACE_Reactor> singleton.


The documentation for this class was generated from the following files:
Generated on Wed Nov 23 15:50:04 2005 for ACE by  doxygen 1.4.5