ACE_Select_Reactor or ACE_WFMO_Reactor.
#include <ace/Reactor.h>
class ACE_Reactor {
public:enum{ GET_MASK = 1, SET_MASK = 2, ADD_MASK = 3, CLR_MASK = 4 };typedef int (*REACTOR_EVENT_HOOK)(void*);static ACE_Reactor *instance (void);static ACE_Reactor *instance ( ACE_Reactor *, int delete_reactor = 0 );static void close_singleton (void);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 (void *);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);virtual void reset_reactor_event_loop (void);ACE_Reactor ( ACE_Reactor_Impl *implementation = 0, int delete_implementation = 0 );virtual ~ACE_Reactor (void);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);virtual int set_timer_queue (ACE_Timer_Queue *timer_queue);virtual int close (void);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 mask );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 *new_sh, ACE_Sig_Action *new_disp = 0 );virtual int remove_handler ( ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask );virtual int remove_handler ( ACE_HANDLE handle, ACE_Reactor_Mask mask );virtual int remove_handler ( const ACE_Handle_Set &handle_set, ACE_Reactor_Mask mask );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_Event_Handler *event_handler);virtual int suspend_handler (ACE_HANDLE handle);virtual int suspend_handler (const ACE_Handle_Set &handles);virtual int suspend_handlers (void);virtual int resume_handler (ACE_Event_Handler *event_handler);virtual int resume_handler (ACE_HANDLE handle);virtual int resume_handler (const ACE_Handle_Set &handles);virtual int resume_handlers (void);virtual long schedule_timer ( ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delta, 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 ( ACE_Event_Handler *event_handler, int dont_call_handle_close = 1 );virtual int cancel_timer ( long timer_id, const void **arg = 0, 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 mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *tv = 0 );virtual void max_notify_iterations (int iterations);virtual int max_notify_iterations (void);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);virtual ACE_Lock &lock (void);virtual void wakeup_all_threads (void);virtual int owner ( ACE_thread_t new_owner, ACE_thread_t *old_owner = 0 );virtual int owner (ACE_thread_t *owner);virtual void requeue_position (int position);virtual int requeue_position (void);virtual int restart (void);virtual int restart (int r);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 );virtual ACE_Reactor_Impl *implementation (void);virtual int current_info (ACE_HANDLE handle, size_t &msg_size);virtual int uses_event_associations (void);ACE_ALLOC_HOOK_DECLARE;void dump (void) const;protected:virtual void implementation (ACE_Reactor_Impl *implementation);ACE_Reactor_Impl *implementation_;int delete_implementation_;static ACE_Reactor *reactor_;static int delete_reactor_;ACE_Reactor (const ACE_Reactor &);ACE_Reactor &operator = (const ACE_Reactor &);};
ACE_Reactor::instance.
static int run_event_loop (void);
static int run_alertable_event_loop (void);
ACE_Reactor::handle_events/ACE_Reactor::alertable_handle_events
method returns -1 or the end_event_loop method is invoked.
static int run_event_loop (ACE_Time_Value &tv);
static int run_alertable_event_loop (ACE_Time_Value &tv);
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.
static int end_event_loop (void);
ACE_Reactor::instance to terminate its event loop
and notifies the ACE_Reactor::instance so that it can wake up
and close down gracefully.
static int event_loop_done (void);
ACE_Reactor::instance's event loop is finished.
static void reset_event_loop (void);
ACE_Reactor::end_event_loop_ static so that the
run_event_loop method can be restarted.
static int check_reconfiguration (void *);
virtual int run_reactor_event_loop (REACTOR_EVENT_HOOK = 0);
virtual int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK = 0);
ACE_Reactor::handle_events/ACE_Reactor::alertable_handle_events
method returns -1 or the end_event_loop method is invoked.
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
);
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.
virtual int end_reactor_event_loop (void);
ACE_Reactor::instance to terminate its event loop
and notifies the ACE_Reactor::instance so that it can wake up
and close down gracefully.
virtual int reactor_event_loop_done (void);
ACE_Reactor::instance's event loop is finished.
virtual void reset_reactor_event_loop (void);
ACE_Reactor::end_event_loop_ static so that the
run_event_loop method can be restarted.
ACE_Reactor (
ACE_Reactor_Impl *implementation = 0,
int delete_implementation = 0
);
implementation. The flag
delete_implementation tells the Reactor whether or not to
delete the implementation on destruction.
virtual ~ACE_Reactor (void);
virtual int open (
size_t max_number_of_handles,
int restart = 0,
ACE_Sig_Handler *signal_handler = 0,
ACE_Timer_Queue *timer_queue = 0
);
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.
virtual int set_sig_handler (ACE_Sig_Handler *signal_handler);
virtual int set_timer_queue (ACE_Timer_Queue *timer_queue);
virtual int close (void);
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
);
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_Handlers
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.
virtual int handle_events (ACE_Time_Value &max_wait_time);
virtual int alertable_handle_events (ACE_Time_Value &max_wait_time);
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.
virtual int register_handler (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask
);
event_handler with mask. The I/O handle will always
come from get_handle on the event_handler.
virtual int register_handler (
ACE_HANDLE io_handle,
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask
);
event_handler with mask. The I/O handle is provided
through the io_handle parameter.
virtual int register_handler (
ACE_Event_Handler *event_handler,
ACE_HANDLE event_handle = ACE_INVALID_HANDLE
);
event_handler that will be notified when
event_handle is signaled. Since no event mask is passed
through this interface, it is assumed that the event_handle
being passed in is an event handle and not an I/O handle.
Originally this interface was available for all platforms, but because ACE_HANDLE is an int on non-Win32 platforms, 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). Therefore, we have restricted this method to Win32 only.
virtual int register_handler (
ACE_HANDLE event_handle,
ACE_HANDLE io_handle,
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask
);
event_handler that will be notified when
event_handle is signaled. mask specifies the network events
that the event_handler is interested in.
virtual int register_handler (
const ACE_Handle_Set &handles,
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask
);
event_handler with all the handles in the Handle_Set.
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
);
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.
virtual int register_handler (
const ACE_Sig_Set &sigset,
ACE_Event_Handler *new_sh,
ACE_Sig_Action *new_disp = 0
);
new_sh to handle a set of signals sigset using the
new_disp.
virtual int remove_handler (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask
);
event_handler. Note that the I/O handle will be
obtained using get_handle method of event_handler . If
mask == ACE_Event_Handler::DONT_CALL then the handle_close
method of the event_handler is not invoked.
virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask);
handle. If mask == ACE_Event_Handler::DONT_CALL
then the handle_close method of the associated event_handler
is not invoked.
virtual int remove_handler (
const ACE_Handle_Set &handle_set,
ACE_Reactor_Mask mask
);
handle_set. If mask ==
ACE_Event_Handler::DONT_CALL then the handle_close method of
the associated event_handlers is not invoked.
virtual int remove_handler (
int signum,
ACE_Sig_Action *new_disp,
ACE_Sig_Action *old_disp = 0,
int sigkey = -1
);
signum.
Install the new disposition (if given) and return the previous
disposition (if desired by the caller). Returns 0 on success and
-1 if signum is invalid.
virtual int remove_handler (const ACE_Sig_Set &sigset);
remove_handler for every signal in sigset.
virtual int suspend_handler (ACE_Event_Handler *event_handler);
event_handler temporarily. Use
ACE_Event_Handler::get_handle to get the handle.
virtual int suspend_handler (ACE_HANDLE handle);
handle temporarily.
virtual int suspend_handler (const ACE_Handle_Set &handles);
handles in handle set temporarily.
virtual int suspend_handlers (void);
handles temporarily.
virtual int resume_handler (ACE_Event_Handler *event_handler);
event_handler. Use ACE_Event_Handler::get_handle to
get the handle.
virtual int resume_handler (ACE_HANDLE handle);
handle.
virtual int resume_handler (const ACE_Handle_Set &handles);
handles in handle set.
virtual int resume_handlers (void);
handles.
virtual long schedule_timer (
ACE_Event_Handler *event_handler,
const void *arg,
const ACE_Time_Value &delta,
const ACE_Time_Value &interval = ACE_Time_Value::zero
);
event_handler that will expire after delay amount
of time, which is specified as relative time to the current
gettimeofday. If it expires then arg is passed in as the
value to the event_handler's handle_timeout callback method.
If interval is != to ACE_Time_Value::zero then it is used to
reschedule the event_handler automatically, also specified
using relative time. This method returns a timer_id that
uniquely identifies the event_handler in an internal list.
This timer_id can be used to cancel an event_handler 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.
virtual int reset_timer_interval (
long timer_id,
const ACE_Time_Value &interval
);
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.
virtual int cancel_timer (
ACE_Event_Handler *event_handler,
int dont_call_handle_close = 1
);
Event_Handlers that match the address of
event_handler. Returns number of handlers cancelled.
virtual int cancel_timer (
long timer_id,
const void **arg = 0,
int dont_call_handle_close = 1
);
Event_Handler that matches the timer_id
value, which was returned from the schedule method. If arg is
non-NULL then it will be set to point to the ``magic cookie''
argument passed in when the Event_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.
virtual int schedule_wakeup (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask masks_to_be_added
);
masks_to_be_added to the event_handler's entry.
event_handler must already have been registered.
virtual int schedule_wakeup (
ACE_HANDLE handle,
ACE_Reactor_Mask masks_to_be_added
);
masks_to_be_added to the handle's entry. event_handler
associated with handle must already have been registered.
virtual int cancel_wakeup (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask masks_to_be_cleared
);
masks_to_be_cleared from the event_handler's entry.
virtual int cancel_wakeup (
ACE_HANDLE handle,
ACE_Reactor_Mask masks_to_be_cleared
);
masks_to_be_cleared from the handle's entry.
virtual int notify (
ACE_Event_Handler *event_handler = 0,
ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value *tv = 0
);
event_handler of mask event. The ACE_Time_Value
indicates how long to blocking trying to notify. If timeout ==
0, the caller will block until action is possible, else will wait
until the relative time specified in timeout elapses).
virtual void max_notify_iterations (int iterations);
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.
virtual int max_notify_iterations (void);
ACE_Event_Handlers that are passed in
via the notify queue before breaking out of its
ACE_Message_Queue::dequeue loop.
virtual int handler (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
ACE_Event_Handler **event_handler = 0
);
handle is associated with a valid Event_Handler
bound to mask. Return the event_handler associated with this
handler if event_handler != 0.
virtual int handler (
int signum,
ACE_Event_Handler **event_handler = 0
);
signum is associated with a valid Event_Handler
bound to a signal. Return the event_handler associated with
this handler if event_handler != 0.
virtual int initialized (void);
virtual size_t size (void);
virtual ACE_Lock &lock (void);
virtual void wakeup_all_threads (void);
virtual int owner (
ACE_thread_t new_owner,
ACE_thread_t *old_owner = 0
);
new_owner.
virtual int owner (ACE_thread_t *owner);
virtual void requeue_position (int position);
virtual int requeue_position (void);
virtual int restart (void);
virtual int restart (int r);
virtual int mask_ops (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask,
int ops
);
event_handler and mask.
virtual int mask_ops (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
int ops
);
handle
and mask.
virtual int ready_ops (
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask mask,
int ops
);
event_handler
and mask.
virtual int ready_ops (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
int ops
);
handle and mask.
virtual ACE_Reactor_Impl *implementation (void);
virtual int current_info (ACE_HANDLE handle, size_t &msg_size);
size returns -1, if not. ACE_HANDLE allows the reactor to
check if the caller is valid. Used for CLASSIX Reactor
implementation.
virtual int uses_event_associations (void);
ACE_ALLOC_HOOK_DECLARE;
void dump (void) const;