#include <Select_Reactor_T.h>
Public Member Functions | |
ACE_Select_Reactor_T (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO) | |
ACE_Select_Reactor_T (size_t size, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO) | |
virtual int | open (size_t max_number_of_handles=DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *=0) |
virtual int | current_info (ACE_HANDLE, size_t &size) |
Returns -1 (not used in this implementation);. | |
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_Queue * | timer_queue (void) const |
Return the current ACE_Timer_Queue. | |
virtual int | close (void) |
Close down the select_reactor and release all of its resources. | |
virtual | ~ACE_Select_Reactor_T (void) |
Close down the select_reactor and release all of its 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 | 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) |
Not implemented. | |
virtual int | register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Not implemented. | |
virtual int | register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *eh, ACE_Reactor_Mask mask) |
Register 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) |
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) |
Calls <remove_handler> for every signal in sigset. | |
virtual int | suspend_handler (ACE_Event_Handler *eh) |
Temporarily suspend the <Event_Handler> associated with eh. | |
virtual int | suspend_handler (ACE_HANDLE handle) |
Temporarily suspend the Event_Handler associated with handle. | |
virtual int | suspend_handler (const ACE_Handle_Set &handles) |
Suspend all handles in handle set temporarily. | |
virtual int | suspend_handlers (void) |
Suspend all the <Event_Handlers> in the Select_Reactor. | |
virtual int | resume_handler (ACE_Event_Handler *eh) |
virtual int | resume_handler (ACE_HANDLE handle) |
virtual int | resume_handler (const ACE_Handle_Set &handles) |
Resume all handles in handle set. | |
virtual int | resume_handlers (void) |
Resume all the <Event_Handlers> in the Select_Reactor. | |
virtual bool | uses_event_associations (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 (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) |
ADD the dispatch MASK "bit" bound with the eh and the mask. | |
virtual int | schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
ADD the dispatch MASK "bit" bound with the handle and the mask. | |
virtual int | cancel_wakeup (ACE_Event_Handler *eh, ACE_Reactor_Mask mask) |
CLR the dispatch MASK "bit" bound with the eh and the mask. | |
virtual int | cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
CLR the dispatch MASK "bit" bound with the handle and the 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 bool | restart (void) |
Get the existing restart value. | |
virtual bool | restart (bool r) |
Set a new value for restart and return the original value. | |
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) |
GET/SET/ADD/CLR the ready "bit" bound with the eh and mask. | |
virtual int | ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops) |
GET/SET/ADD/CLR the ready "bit" bound with the handle and mask. | |
virtual void | wakeup_all_threads (void) |
Wake up all threads in waiting in the event loop. | |
virtual int | owner (ACE_thread_t n_id, ACE_thread_t *o_id=0) |
Set the new owner of the thread and return the old owner. | |
virtual int | owner (ACE_thread_t *) |
Return the current owner of the thread. | |
virtual ACE_Event_Handler * | find_handler (ACE_HANDLE handle) |
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 bool | initialized (void) |
Returns true if we've been successfully initialized, else false. | |
virtual size_t | size (void) const |
virtual ACE_Lock & | lock (void) |
virtual void | dump (void) const |
Dump the state of an object. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Member Functions | |
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) |
Register a set of handles. | |
virtual int | remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask) |
virtual int | remove_handler_i (const ACE_Handle_Set &handles, ACE_Reactor_Mask) |
Remove a set of handles. | |
virtual int | suspend_i (ACE_HANDLE handle) |
Suspend the <Event_Handler> associated with handle. | |
virtual int | is_suspended_i (ACE_HANDLE handle) |
virtual int | resume_i (ACE_HANDLE handle) |
Resume the <Event_Handler> associated with handle. | |
virtual ACE_Event_Handler * | find_handler_i (ACE_HANDLE handle) |
Implement the public handler method. | |
virtual int | handler_i (ACE_HANDLE handle, ACE_Reactor_Mask, ACE_Event_Handler **=0) |
Implement the public handler method. | |
virtual int | handler_i (int signum, ACE_Event_Handler **=0) |
Implement the public handler method. | |
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) |
Take corrective action when errors occur. | |
virtual int | check_handles (void) |
Make sure the handles are all valid. | |
virtual int | wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &, ACE_Time_Value *) |
Wait for events to occur. | |
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) |
int | release_token (void) |
Release the token lock when a Win32 structured exception occurs. | |
int | handle_events_i (ACE_Time_Value *max_wait_time=0) |
Stops the VC++ compiler from bitching about exceptions and destructors. | |
Protected Attributes | |
ACE_SELECT_REACTOR_TOKEN | token_ |
Synchronization token for the MT_SAFE ACE_Select_Reactor. | |
ACE_Lock_Adapter < ACE_SELECT_REACTOR_TOKEN > | lock_adapter_ |
Adapter used to return internal lock to outside world. | |
sig_atomic_t | deactivated_ |
Private Member Functions | |
ACE_Select_Reactor_T (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &) | |
Deny access since member-wise won't work... | |
ACE_Select_Reactor_T < ACE_SELECT_REACTOR_TOKEN > & | operator= (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &) |
The 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_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_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T | ( | ACE_Sig_Handler * | sh = 0 , |
|
ACE_Timer_Queue * | tq = 0 , |
|||
int | disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT , |
|||
ACE_Reactor_Notify * | notify = 0 , |
|||
bool | mask_signals = true , |
|||
int | s_queue = ACE_SELECT_TOKEN::FIFO | |||
) | [inline] |
If disable_notify_pipe is non-0 then the reactor will not create a notification pipe, which will save two I/O handles but will elide the <notify()> feature. If mask_signals is true the reactor is "signal-safe" when dispatching handlers to signal events, whereas if mask_signals is false the reactor will be more efficient, but not signal-safe (which may be perfectly fine if your application doesn't use the reactor to handle signals).
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T | ( | size_t | size, | |
bool | restart = false , |
|||
ACE_Sig_Handler * | sh = 0 , |
|||
ACE_Timer_Queue * | tq = 0 , |
|||
int | disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT , |
|||
ACE_Reactor_Notify * | notify = 0 , |
|||
bool | mask_signals = true , |
|||
int | s_queue = ACE_SELECT_TOKEN::FIFO | |||
) | [inline] |
Initialize ACE_Select_Reactor
with size
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::~ACE_Select_Reactor_T | ( | void | ) | [inline, virtual] |
Close down the select_reactor and release all of its resources.
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T | ( | const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > & | ) | [private] |
Deny access since member-wise won't work...
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events | ( | ACE_Time_Value & | max_wait_time | ) | [inline, virtual] |
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events | ( | ACE_Time_Value * | max_wait_time = 0 |
) | [inline, virtual] |
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready | ( | ACE_Select_Reactor_Handle_Set & | handle_set | ) | [inline, protected, virtual] |
Check if there are any HANDLEs enabled in the <ready_set_>, and if so, update the handle_set and return the number ready. If there aren't any HANDLEs enabled return 0.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready_i | ( | ACE_Select_Reactor_Handle_Set & | handle_set | ) | [inline, protected, virtual] |
Implement the <any_ready> method, assuming that the Sig_Guard is beign held
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer | ( | long | timer_id, | |
const void ** | arg = 0 , |
|||
int | dont_call_handle_close = 1 | |||
) | [inline, virtual] |
Cancel the single 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer | ( | ACE_Event_Handler * | event_handler, | |
int | dont_call_handle_close = 1 | |||
) | [inline, virtual] |
Cancel all <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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::check_handles | ( | void | ) | [inline, protected, virtual] |
Make sure the handles are all valid.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::close | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::current_info | ( | ACE_HANDLE | , | |
size_t & | size | |||
) | [inline, virtual] |
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivate | ( | int | do_stop | ) | [inline, virtual] |
Control whether the Reactor will handle any more incoming events or not. If do_stop == 1, the Reactor will be disabled. By default, a reactor is in active state and can be deactivated/reactived as wish.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated | ( | void | ) | [inline, virtual] |
Return the status of Reactor. If this function returns 0, the reactor is actively handling events. If it returns non-zero, <handling_events> and <handle_alertable_events> return -1 immediately.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch | ( | int | nfound, | |
ACE_Select_Reactor_Handle_Set & | dispatch_set | |||
) | [inline, protected, virtual] |
Template Method that dispatches 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.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers | ( | ACE_Select_Reactor_Handle_Set & | dispatch_set, | |
int & | number_of_active_handles, | |||
int & | number_of_handlers_dispatched | |||
) | [inline, protected, virtual] |
Dispatch all the input/output/except handlers that are enabled in the <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.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 | |||
) | [inline, protected, virtual] |
Factors the dispatching of an io handle set (each WRITE, EXCEPT or READ set of handles). It updates the <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.
Reimplemented in ACE_Priority_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_notification_handlers | ( | ACE_Select_Reactor_Handle_Set & | dispatch_set, | |
int & | number_of_active_handles, | |||
int & | number_of_handlers_dispatched | |||
) | [inline, protected, virtual] |
Dispatch any notification handlers. Returns -1 if the state of the <wait_set_> has changed, else returns number of handlers notified.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_timer_handlers | ( | int & | number_dispatched | ) | [inline, protected, virtual] |
Dispatch all timer handlers that have expired. Returns -1 if the state of the <wait_set_> has changed, else 0. <number_dispatched> is set to the number of timer handlers dispatched.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dump | ( | void | ) | const [inline, virtual] |
ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler | ( | ACE_HANDLE | handle | ) | [inline, virtual] |
Return the Event_Handler associated with handle. Return 0 if handle is not registered.
Implements ACE_Reactor_Impl.
ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler_i | ( | ACE_HANDLE | handle | ) | [inline, protected, virtual] |
Implement the public handler method.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_error | ( | void | ) | [inline, protected, virtual] |
Take corrective action when errors occur.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events | ( | ACE_Time_Value & | max_wait_time | ) | [inline, virtual] |
This method is just like the one above, except the max_wait_time value is a reference and can therefore never be NULL.
Current <alertable_handle_events> is identical to <handle_events>.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events | ( | ACE_Time_Value * | max_wait_time = 0 |
) | [inline, virtual] |
This event loop driver that blocks for 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_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>.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events_i | ( | ACE_Time_Value * | max_wait_time = 0 |
) | [inline, protected] |
Stops the VC++ compiler from bitching about exceptions and destructors.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler | ( | int | signum, | |
ACE_Event_Handler ** | handler = 0 | |||
) | [inline, virtual] |
Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the eh associated with this handler if eh != 0.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
ACE_Event_Handler ** | eh = 0 | |||
) | [inline, virtual] |
Check to see if handle is associated with a valid Event_Handler bound to mask. Return the eh associated with this handler if eh != 0.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i | ( | int | signum, | |
ACE_Event_Handler ** | eh = 0 | |||
) | [inline, protected, virtual] |
Implement the public handler method.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
ACE_Event_Handler ** | eh = 0 | |||
) | [inline, protected, virtual] |
Implement the public handler method.
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::initialized | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::is_suspended_i | ( | ACE_HANDLE | handle | ) | [inline, protected, virtual] |
Check to see if the <Event_Handler> associated with handle is suspended. Returns 0 if not, 1 if so.
Implements ACE_Select_Reactor_Impl.
ACE_Lock & ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock | ( | void | ) | [inline, virtual] |
Returns a reference to the ACE_Reactor_Token that is used to serialize the internal processing logic. This can be useful for situations where you need to avoid deadlock efficiently when ACE_Event_Handlers are used in multiple threads.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::mask_ops | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
int | ops | |||
) | [inline, virtual] |
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::mask_ops | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask, | |||
int | ops | |||
) | [inline, virtual] |
GET/SET/ADD/CLR the dispatch mask "bit" bound with the eh and mask.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations | ( | void | ) | [inline, virtual] |
Get the maximum number of times that the <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.
Implements ACE_Reactor_Impl.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations | ( | int | iterations | ) | [inline, virtual] |
Set the maximum number of times that the <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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify | ( | ACE_Event_Handler * | eh = 0 , |
|
ACE_Reactor_Mask | mask = ACE_Event_Handler::EXCEPT_MASK , |
|||
ACE_Time_Value * | timeout = 0 | |||
) | [inline, virtual] |
Called by a thread when it wants to unblock the Select_Reactor. This wakeups the <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).
Implements ACE_Reactor_Impl.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
ACE_Handle_Set & | ready_mask, | |||
ACE_Event_Handler * | eh, | |||
ACE_EH_PTMF | callback | |||
) | [inline, protected, virtual] |
Notify the appropriate <callback> in the context of the eh associated with handle that a particular event has occurred.
Reimplemented in ACE_TP_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::open | ( | size_t | max_number_of_handles = DEFAULT_SIZE , |
|
bool | restart = false , |
|||
ACE_Sig_Handler * | sh = 0 , |
|||
ACE_Timer_Queue * | tq = 0 , |
|||
int | disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT , |
|||
ACE_Reactor_Notify * | notify = 0 | |||
) | [inline, virtual] |
Initialize the ACE_Select_Reactor
to manage
ACE_Reactor's
handle_events
method will be restarted automatically when EINTR
occurs. If Implements ACE_Reactor_Impl.
ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>& ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::operator= | ( | const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > & | ) | [private] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner | ( | ACE_thread_t * | t_id | ) | [inline, virtual] |
Return the current owner of the thread.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner | ( | ACE_thread_t | n_id, | |
ACE_thread_t * | o_id = 0 | |||
) | [inline, virtual] |
Set the new owner of the thread and return the old owner.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ready_ops | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask, | |||
int | ops | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ready_ops | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask, | |||
int | ops | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | const ACE_Sig_Set & | sigset, | |
ACE_Event_Handler * | new_sh, | |||
ACE_Sig_Action * | new_disp = 0 | |||
) | [inline, virtual] |
Registers new_sh to handle a set of signals sigset using the new_disp.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 | |||
) | [inline, virtual] |
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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | const ACE_Handle_Set & | handles, | |
ACE_Event_Handler * | eh, | |||
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | ACE_HANDLE | event_handle, | |
ACE_HANDLE | io_handle, | |||
ACE_Event_Handler * | event_handler, | |||
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | ACE_Event_Handler * | event_handler, | |
ACE_HANDLE | event_handle = ACE_INVALID_HANDLE | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | ACE_HANDLE | handle, | |
ACE_Event_Handler * | eh, | |||
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
Register a 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
Register a eh with a particular mask. Note that the <Select_Reactor> will call ACE_Event_Handler::get_handle() to extract the underlying I/O handle.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i | ( | const ACE_Handle_Set & | handles, | |
ACE_Event_Handler * | handler, | |||
ACE_Reactor_Mask | mask | |||
) | [inline, protected, virtual] |
Register a set of handles.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i | ( | ACE_HANDLE | handle, | |
ACE_Event_Handler * | eh, | |||
ACE_Reactor_Mask | mask | |||
) | [inline, protected, virtual] |
Do the work of actually binding the handle and eh with the mask.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::release_token | ( | void | ) | [inline, protected] |
Release the token lock when a Win32 structured exception occurs.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler | ( | const ACE_Sig_Set & | sigset | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler | ( | int | signum, | |
ACE_Sig_Action * | new_disp, | |||
ACE_Sig_Action * | old_disp = 0 , |
|||
int | sigkey = -1 | |||
) | [inline, virtual] |
Remove the ACE_Event_Handler currently associated with 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler | ( | const ACE_Handle_Set & | handle_set, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
Removes all the 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
Removes the 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
Removes the 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.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i | ( | const ACE_Handle_Set & | handles, | |
ACE_Reactor_Mask | mask | |||
) | [inline, protected, virtual] |
Remove a set of handles.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask | |||
) | [inline, protected, virtual] |
Do the work of actually unbinding the handle and eh with the mask.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::renew | ( | void | ) | [inline, protected, virtual] |
Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>.
Implements ACE_Select_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position | ( | void | ) | [inline, virtual] |
Get position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback.
Implements ACE_Reactor_Impl.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position | ( | int | rp | ) | [inline, virtual] |
Set position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::reset_timer_interval | ( | long | timer_id, | |
const ACE_Time_Value & | interval | |||
) | [inline, virtual] |
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.
Implements ACE_Reactor_Impl.
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart | ( | bool | r | ) | [inline, virtual] |
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler | ( | const ACE_Handle_Set & | handles | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler | ( | ACE_HANDLE | handle | ) | [inline, virtual] |
Resume a temporarily suspended Event_Handler associated with handle.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler | ( | ACE_Event_Handler * | eh | ) | [inline, virtual] |
Resume a temporarily suspend Event_Handler associated with eh.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handlers | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_i | ( | ACE_HANDLE | handle | ) | [inline, protected, virtual] |
Resume the <Event_Handler> associated with handle.
long ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_timer | ( | ACE_Event_Handler * | event_handler, | |
const void * | arg, | |||
const ACE_Time_Value & | delay, | |||
const ACE_Time_Value & | interval = ACE_Time_Value::zero | |||
) | [inline, virtual] |
Schedule an ACE_Event_Handler that will expire after an 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.
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 |
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup | ( | ACE_HANDLE | handle, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup | ( | ACE_Event_Handler * | eh, | |
ACE_Reactor_Mask | mask | |||
) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::set_sig_handler | ( | ACE_Sig_Handler * | signal_handler | ) | [inline, virtual] |
size_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::size | ( | void | ) | const [inline, virtual] |
Returns the current size of the Reactor's internal descriptor table.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler | ( | const ACE_Handle_Set & | handles | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler | ( | ACE_HANDLE | handle | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler | ( | ACE_Event_Handler * | eh | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handlers | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_i | ( | ACE_HANDLE | handle | ) | [inline, protected, virtual] |
Suspend the <Event_Handler> associated with handle.
ACE_Timer_Queue * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue | ( | void | ) | const [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue | ( | ACE_Timer_Queue * | tq | ) | [inline, virtual] |
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::uses_event_associations | ( | void | ) | [inline, virtual] |
Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise. Since the Select_Reactor does not do any event associations, this function always return false.
Implements ACE_Reactor_Impl.
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wait_for_multiple_events | ( | ACE_Select_Reactor_Handle_Set & | dispatch_set, | |
ACE_Time_Value * | max_wait_time | |||
) | [inline, protected, virtual] |
Wait for events to occur.
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wakeup_all_threads | ( | void | ) | [inline, virtual] |
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::work_pending | ( | const ACE_Time_Value & | max_wait_time = ACE_Time_Value::zero |
) | [inline, 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".
Implements ACE_Reactor_Impl.
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_ALLOC_HOOK_DECLARE |
Declare the dynamic allocation hooks.
Reimplemented from ACE_Reactor_Impl.
Reimplemented in ACE_Priority_Reactor, and ACE_TP_Reactor.
sig_atomic_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated_ [protected] |
This flag is used to keep track of whether we are actively handling events or not.
ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock_adapter_ [protected] |
Adapter used to return internal lock to outside world.
ACE_SELECT_REACTOR_TOKEN ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::token_ [protected] |
Synchronization token for the MT_SAFE ACE_Select_Reactor.