#include <ace/Select_Reactor_T.h>
template<class ACE_SELECT_REACTOR_TOKEN> class ACE_Select_Reactor_T : public ACE_Select_Reactor_Impl {
public:ACE_Select_Reactor_T ( ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0, int disable_notify_pipe = 0, ACE_Reactor_Notify *notify = 0, int mask_signals = 1 );ACE_Select_Reactor_T ( size_t size, int restart = 0, ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0, int disable_notify_pipe = 0, ACE_Reactor_Notify *notify = 0, int mask_signals = 1 );virtual int open ( size_t max_number_of_handles = DEFAULT_SIZE, int restart = 0, ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0, int disable_notify_pipe = 0, ACE_Reactor_Notify * = 0 );virtual int current_info (ACE_HANDLE, size_t & );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 ~ACE_Select_Reactor_T (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 deactivated (void);virtual void deactivate (int do_stop);virtual int register_handler ( ACE_Event_Handler *eh, ACE_Reactor_Mask mask );virtual int register_handler ( ACE_HANDLE handle, ACE_Event_Handler *eh, 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 *eh, 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 *eh, ACE_Reactor_Mask mask );virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask);virtual int remove_handler ( const ACE_Handle_Set &handle_set, ACE_Reactor_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 *eh);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 *eh);virtual int resume_handler (ACE_HANDLE handle);virtual int resume_handler (const ACE_Handle_Set &handles);virtual int resume_handlers (void);virtual int uses_event_associations (void);virtual long schedule_timer ( ACE_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 *eh, ACE_Reactor_Mask mask );virtual int schedule_wakeup ( ACE_HANDLE handle, ACE_Reactor_Mask mask );virtual int cancel_wakeup ( ACE_Event_Handler *eh, ACE_Reactor_Mask mask );virtual int cancel_wakeup ( ACE_HANDLE handle, ACE_Reactor_Mask mask );virtual int notify ( ACE_Event_Handler * = 0, ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value * = 0 );virtual void max_notify_iterations (int);virtual int max_notify_iterations (void);virtual int restart (void);virtual int restart (int r);virtual void requeue_position (int);virtual int requeue_position (void);virtual int mask_ops ( ACE_Event_Handler *eh, 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 *eh, ACE_Reactor_Mask mask, int ops );virtual int ready_ops ( ACE_HANDLE handle, ACE_Reactor_Mask, int ops );virtual void wakeup_all_threads (void);virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);virtual int owner (ACE_thread_t *);virtual int handler ( ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **eh = 0 );virtual int handler (int signum, ACE_Event_Handler ** = 0);virtual int initialized (void);virtual size_t size (void);virtual ACE_Lock &lock (void);virtual void dump (void) const;ACE_ALLOC_HOOK_DECLARE;protected:virtual int register_handler_i ( ACE_HANDLE handle, ACE_Event_Handler *eh, ACE_Reactor_Mask mask );virtual int register_handler_i ( const ACE_Handle_Set &handles, ACE_Event_Handler *handler, ACE_Reactor_Mask mask );virtual int remove_handler_i ( ACE_HANDLE handle, ACE_Reactor_Mask );virtual int remove_handler_i ( const ACE_Handle_Set &handles, ACE_Reactor_Mask );virtual int suspend_i (ACE_HANDLE handle);virtual int resume_i (ACE_HANDLE handle);virtual int handler_i ( ACE_HANDLE handle, ACE_Reactor_Mask, ACE_Event_Handler ** = 0 );virtual int handler_i (int signum, ACE_Event_Handler ** = 0);virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set);virtual int any_ready_i ( ACE_Select_Reactor_Handle_Set &handle_set );virtual int handle_error (void);virtual int check_handles (void);virtual int wait_for_multiple_events ( ACE_Select_Reactor_Handle_Set &, ACE_Time_Value * );virtual int dispatch ( int nfound, ACE_Select_Reactor_Handle_Set & );virtual int dispatch_timer_handlers (int &number_dispatched);virtual int dispatch_notification_handlers ( ACE_Select_Reactor_Handle_Set &dispatch_set, int &number_of_active_handles, int &number_of_handlers_dispatched );virtual int dispatch_io_handlers ( ACE_Select_Reactor_Handle_Set &dispatch_set, int &number_of_active_handles, int &number_of_handlers_dispatched );virtual int dispatch_io_set ( int number_of_active_handles, int &number_of_handlers_dispatched, int mask, ACE_Handle_Set& dispatch_mask, ACE_Handle_Set& ready_mask, ACE_EH_PTMF callback );virtual void notify_handle ( ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Handle_Set &, ACE_Event_Handler *eh, ACE_EH_PTMF callback );virtual void renew (void);ACE_SELECT_REACTOR_TOKEN token_;ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> lock_adapter_;int release_token (void);int handle_events_i (ACE_Time_Value *max_wait_time = 0);sig_atomic_t deactivated_;int mask_signals_;private:inline ACE_UNIMPLEMENTED_FUNC ( ACE_Select_Reactor_T (const ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN> &) );};
ACE_Select_Reactor is an object-oriented event
demultiplexor and event handler dispatcher. The sources of
events that the ACE_Select_Reactor waits for and dispatches
includes I/O events, signals, and timer events. All public
methods acquire the main ACE_Select_Reactor_Token lock and
call down to private or protected methods, which assume that
the lock is held and so therefore don't (re)acquire the lock.
ACE_Select_Reactor_T (
ACE_Sig_Handler * = 0,
ACE_Timer_Queue * = 0,
int disable_notify_pipe = 0,
ACE_Reactor_Notify *notify = 0,
int mask_signals = 1
);
ACE_Select_Reactor with the default size.
ACE_Select_Reactor_T (
size_t size,
int restart = 0,
ACE_Sig_Handler * = 0,
ACE_Timer_Queue * = 0,
int disable_notify_pipe = 0,
ACE_Reactor_Notify *notify = 0,
int mask_signals = 1
);
ACE_Select_Reactor with size size.
virtual int open (
size_t max_number_of_handles = DEFAULT_SIZE,
int restart = 0,
ACE_Sig_Handler * = 0,
ACE_Timer_Queue * = 0,
int disable_notify_pipe = 0,
ACE_Reactor_Notify * = 0
);
ACE_Select_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. If disable_notify_pipe is non-0 the
notification pipe is not created, thereby saving two I/O handles.
virtual int current_info (ACE_HANDLE, size_t & );
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 ~ACE_Select_Reactor_T (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 timer events, I/O events,
or signal 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 I/O and Timer ACE_Event_Handlers
that were dispatched, 0 if the max_wait_time elapsed without
dispatching any handlers, or -1 if something goes wrong.
Current alertable_handle_events is identical to
handle_events.
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.
Current alertable_handle_events is identical to
handle_events.
virtual int deactivated (void);
handling_events and
handle_alertable_events return -1 immediately.
virtual void deactivate (int do_stop);
do_stop == 1, the Reactor will be disabled. By default, a reactor
is in active state and can be deactivated/reactived as wish.
= Register and remove ACE_Event_Handlers.
virtual int register_handler (
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
eh with a particular mask. Note that the
Select_Reactor will call ACE_Event_Handler::get_handle to
extract the underlying I/O handle.
virtual int register_handler (
ACE_HANDLE handle,
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
eh with a particular mask. Note that since the
handle is given the Select_Reactor will *not* call
ACE_Event_Handler::get_handle to extract the underlying 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_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 *eh,
ACE_Reactor_Mask mask
);
eh 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 *eh,
ACE_Reactor_Mask mask
);
mask binding of eh from the Select_Reactor. If
there are no more bindings for this eh then it is removed from
the Select_Reactor. Note that the Select_Reactor will call
ACE_Event_Handler::get_handle to extract the underlying I/O
handle.
virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask);
mask bind of Event_Handler whose handle is
handle from the Select_Reactor. If there are no more bindings
for this eh then it is removed from the Select_Reactor.
virtual int remove_handler (
const ACE_Handle_Set &handle_set,
ACE_Reactor_Mask
);
mask bindings for handles in the handle_set
bind of Event_Handler. If there are no more bindings for any
of these handlers then they are removed from the Select_Reactor.
virtual int remove_handler (
int signum,
ACE_Sig_Action *new_disp,
ACE_Sig_Action *old_disp = 0,
int sigkey = -1
);
signum.
sigkey is ignored in this implementation since there is only
one instance of a signal handler. 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 *eh);
Event_Handler associated with eh.
virtual int suspend_handler (ACE_HANDLE handle);
Event_Handler associated with handle.
virtual int suspend_handler (const ACE_Handle_Set &handles);
handles in handle set temporarily.
virtual int suspend_handlers (void);
Event_Handlers in the Select_Reactor.
virtual int resume_handler (ACE_Event_Handler *eh);
Event_Handler associated with
eh.
virtual int resume_handler (ACE_HANDLE handle);
Event_Handler associated with
handle.
virtual int resume_handler (const ACE_Handle_Set &handles);
handles in handle set.
virtual int resume_handlers (void);
Event_Handlers in the Select_Reactor.
virtual int uses_event_associations (void);
virtual long schedule_timer (
ACE_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 delta 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, which is 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. If dont_call_handle_close is 0 then the
handle_close method of event_handler will be invoked.
Returns number of handler's cancelled.
virtual int cancel_timer (
long timer_id,
const void **arg = 0,
int dont_call_handle_close = 1
);
ACE_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.
If dont_call_handle_close is 0 then the handle_close method
of event_handler will be invoked. Returns 1 if cancellation
succeeded and 0 if the timer_id wasn't found.
virtual int schedule_wakeup (
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
eh and the mask.
virtual int schedule_wakeup (
ACE_HANDLE handle,
ACE_Reactor_Mask mask
);
handle and the mask.
virtual int cancel_wakeup (
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
eh and the mask.
virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask);
handle and the mask.
virtual int notify (
ACE_Event_Handler * = 0,
ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value * = 0
);
ACE_Select_Reactor if currently blocked in
select/poll. Pass over both the Event_Handler *and* the
mask to allow the caller to dictate which Event_Handler
method the Select_Reactor will invoke. The ACE_Time_Value
indicates how long to blocking trying to notify the
Select_Reactor. 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);
ACE_Select_Reactor_Notify::handle_input method will iterate and
dispatch the ACE_Event_Handlers that are passed in via the
notify pipe before breaking out of its recv loop. By default,
this is set to -1, which means "iterate until the pipe 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_Select_Reactor_Notify::handle_input method will iterate and
dispatch the ACE_Event_Handlers that are passed in via the
notify pipe before breaking out of its recv loop.
virtual int restart (void);
virtual int restart (int r);
virtual void requeue_position (int);
notify callback.
virtual int requeue_position (void);
notify callback.
virtual int mask_ops (
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask,
int ops
);
eh 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 *eh,
ACE_Reactor_Mask mask,
int ops
);
eh and mask.
virtual int ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops);
handle and mask.
virtual void wakeup_all_threads (void);
= Only the owner thread that can perform a handle_events.
virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
virtual int owner (ACE_thread_t *);
virtual int handler (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
ACE_Event_Handler **eh = 0
);
handle is associated with a valid Event_Handler
bound to mask. Return the eh associated with this handler
if eh != 0.
virtual int handler (int signum, ACE_Event_Handler ** = 0);
signum is associated with a valid Event_Handler
bound to a signal. Return the eh associated with this
handler if eh != 0.
virtual int initialized (void);
virtual size_t size (void);
virtual ACE_Lock &lock (void);
ACE_Select_Reactor_Token that is
used to serialize the internal Select_Reactor's processing logic.
This can be useful for situations where you need to avoid
deadlock efficiently when ACE_Event_Handlers are used in
multiple threads.
virtual void dump (void) const;
ACE_ALLOC_HOOK_DECLARE;
Select_Reactor's token
lock is held by the public methods that call down to them.
virtual int register_handler_i (
ACE_HANDLE handle,
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
handle and eh with the
mask.
virtual int register_handler_i (
const ACE_Handle_Set &handles,
ACE_Event_Handler *handler,
ACE_Reactor_Mask mask
);
handles.
virtual int remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask);
handle and eh with the
mask.
virtual int remove_handler_i (
const ACE_Handle_Set &handles,
ACE_Reactor_Mask
);
handles.
virtual int suspend_i (ACE_HANDLE handle);
Event_Handler associated with handle
virtual int resume_i (ACE_HANDLE handle);
Event_Handler associated with handle
virtual int handler_i (
ACE_HANDLE handle,
ACE_Reactor_Mask,
ACE_Event_Handler ** = 0
);
handler method.
virtual int handler_i (int signum, ACE_Event_Handler ** = 0);
handler method.
virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set);
ready_set_, and
if so, update the handle_set and return the number ready. If
there aren't any HANDLEs enabled return 0.
virtual int any_ready_i (ACE_Select_Reactor_Handle_Set &handle_set);
any_ready method, assuming that the Sig_Guard is
beign held
virtual int handle_error (void);
virtual int check_handles (void);
virtual int wait_for_multiple_events (
ACE_Select_Reactor_Handle_Set &,
ACE_Time_Value *
);
virtual int dispatch (int nfound, ACE_Select_Reactor_Handle_Set &);
ACE_Event_Handlers for time
events, I/O events, and signal events. Returns the total number
of ACE_Event_Handlers that were dispatched or -1 if something
goes wrong.
virtual int dispatch_timer_handlers (int &number_dispatched);
wait_set_ has changed, else 0.
number_dispatched is set to the number of timer handlers
dispatched.
virtual int dispatch_notification_handlers (
ACE_Select_Reactor_Handle_Set &dispatch_set,
int &number_of_active_handles,
int &number_of_handlers_dispatched
);
wait_set_ has changed, else returns number of handlers
notified.
virtual int dispatch_io_handlers (
ACE_Select_Reactor_Handle_Set &dispatch_set,
int &number_of_active_handles,
int &number_of_handlers_dispatched
);
dispatch_set. Updates number_of_active_handles and
number_of_handlers_dispatched according to the behavior of the
number Returns -1 if the state of the wait_set_ has changed,
else 0.
virtual int dispatch_io_set (
int number_of_active_handles,
int &number_of_handlers_dispatched,
int mask,
ACE_Handle_Set& dispatch_mask,
ACE_Handle_Set& ready_mask,
ACE_EH_PTMF callback
);
number_of_handlers_dispatched and invokes this-notify_handle
for all the handles in dispatch_set using the mask,
ready_set and callback parameters. Must return -1 if
this-state_changed otherwise it must return 0.
virtual void notify_handle (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
ACE_Handle_Set &,
ACE_Event_Handler *eh,
ACE_EH_PTMF callback
);
callback in the context of the eh
associated with handle that a particular event has occurred.
virtual void renew (void);
requeue_position_.
ACE_SELECT_REACTOR_TOKEN token_;
ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> lock_adapter_;
int release_token (void);
int handle_events_i (ACE_Time_Value *max_wait_time = 0);
sig_atomic_t deactivated_;
int mask_signals_;