#include <ace/Select_Reactor.h>
class ACE_Select_Reactor : public ACE_Reactor_Impl {
public:
enum{ DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE };
ACE_Select_Reactor (ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0);
ACE_Select_Reactor ( size_t size, int restart = 0, ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0 );
virtual int open ( size_t size = DEFAULT_SIZE, int restart = 0, ACE_Sig_Handler * = 0, ACE_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 ~ACE_Select_Reactor (void);
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 *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_time, const ACE_Time_Value &interval = ACE_Time_Value::zero );
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 requeue_position (int);
virtual int requeue_position (void);
virtual void max_notify_iterations (int);
virtual int max_notify_iterations (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 handle_error (void);
virtual int check_handles (void);
virtual int bit_ops ( ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Select_Reactor_Handle_Set &wait_Set, int ops );
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 (void);
virtual int dispatch_notification_handlers ( int &number_of_active_handles, ACE_Select_Reactor_Handle_Set &dispatch_set );
virtual int dispatch_io_handlers ( int &number_of_active_handles, ACE_Select_Reactor_Handle_Set &dispatch_set );
virtual int dispatch_io_set ( int number_of_active_handles, int& number_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 );
ACE_Select_Reactor_Handler_Repository handler_rep_;
ACE_Timer_Queue *timer_queue_;
int delete_timer_queue_;
ACE_Sig_Handler *signal_handler_;
int delete_signal_handler_;
ACE_Select_Reactor_Handle_Set wait_set_;
ACE_Select_Reactor_Handle_Set suspend_set_;
ACE_Select_Reactor_Handle_Set ready_set_;
int restart_;
int requeue_position_;
int max_notify_iterations_;
int initialized_;
ACE_thread_t owner_;
int state_changed_;
ACE_Select_Reactor_Token token_;
ACE_Lock_Adapter<ACE_Select_Reactor_Token> lock_adapter_;
ACE_Select_Reactor_Notify notify_handler_;
void renew (void);
friend class ACE_Select_Reactor_Notify;
friend class ACE_Select_Reactor_Handler_Repository;
private:
int release_token (void);
int handle_events_i (ACE_Time_Value *max_wait_time = 0);
ACE_Select_Reactor (const ACE_Select_Reactor &);
ACE_Select_Reactor &operator = (const ACE_Select_Reactor &);
};
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 (ACE_Sig_Handler * = 0, ACE_Timer_Queue * = 0);
ACE_Select_Reactor
with the default size.
ACE_Select_Reactor (
size_t size,
int restart = 0,
ACE_Sig_Handler * = 0,
ACE_Timer_Queue * = 0
);
ACE_Select_Reactor
with size size
.
virtual int open (
size_t size = DEFAULT_SIZE,
int restart = 0,
ACE_Sig_Handler * = 0,
ACE_Timer_Queue * = 0
);
ACE_Select_Reactor
with size size
.
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 (void);
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 ACE_Event_Handler
s 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
.
= Register and remove ACE_Event_Handler
s.
virtual int register_handler (
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask
);
eh
with a particular mask
. Note that the
Select_Reactor
will call eh-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
eh-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
eh-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_time,
const ACE_Time_Value &interval = ACE_Time_Value::zero
);
event_handler
that will expire after delta_time
amount of time. 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. 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 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 requeue_position (int);
virtual int requeue_position (void);
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 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 handle_error (void);
virtual int check_handles (void);
virtual int bit_ops (
ACE_HANDLE handle,
ACE_Reactor_Mask mask,
ACE_Select_Reactor_Handle_Set &wait_Set,
int ops
);
wait_set_
mask and ready_set_
mask.
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_Handler
s for time
events, I/O events, and signal events. Returns the total number
of ACE_Event_Handler
s that were dispatched or -1 if something
goes wrong.
virtual int dispatch_timer_handlers (void);
wait_set_
has changed, else returns number of timer
handlers dispatched.
virtual int dispatch_notification_handlers (
int &number_of_active_handles,
ACE_Select_Reactor_Handle_Set &dispatch_set
);
wait_set_
has changed, else returns number of handlers
notified.
virtual int dispatch_io_handlers (
int &number_of_active_handles,
ACE_Select_Reactor_Handle_Set &dispatch_set
);
dispatch_set
. Returns -1 if the state of the wait_set_
has changed, else returns number of handlers dispatched.
virtual int dispatch_io_set (
int number_of_active_handles,
int& number_dispatched,
int mask,
ACE_Handle_Set& dispatch_mask,
ACE_Handle_Set& ready_mask,
ACE_EH_PTMF callback
);
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.
ACE_Select_Reactor_Handler_Repository handler_rep_;
ACE_HANDLEs
to ACE_Event_Handler *
's.
ACE_Timer_Queue *timer_queue_;
int delete_timer_queue_;
ACE_Sig_Handler *signal_handler_;
int delete_signal_handler_;
ACE_Select_Reactor_Handle_Set wait_set_;
ACE_Select_Reactor_Handle_Set suspend_set_;
ACE_Select_Reactor_Handle_Set ready_set_;
int restart_;
int requeue_position_;
int max_notify_iterations_;
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."
int initialized_;
ACE_thread_t owner_;
int state_changed_;
ACE_Event_Handlers
, else false. This is used to determine
whether we need to make another trip through the
Select_Reactor
's wait_for_multiple_events
loop.
ACE_Select_Reactor_Token token_;
ACE_Lock_Adapter<ACE_Select_Reactor_Token> lock_adapter_;
ACE_Select_Reactor_Notify notify_handler_;
void renew (void);
requeue_position_
.
friend class ACE_Select_Reactor_Notify;
friend class ACE_Select_Reactor_Handler_Repository;