#include <Select_Reactor_T.h>
Inheritance diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:
Public Methods | |
| 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, int s_queue=ACE_SELECT_TOKEN::FIFO) | |
| 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, int s_queue=ACE_SELECT_TOKEN::FIFO) | |
| 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 &) |
| 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 | set_timer_queue (ACE_Timer_Queue *tq) |
| 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 int | 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 int | restart (void) |
| Get the existing restart value. | |
| virtual int | restart (int r) |
| Set a new value for restart and return the original value. | |
| virtual 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 int | 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 Methods | |
| 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_ |
| int | mask_signals_ |
Private Methods | |
| 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_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.
|
||||||||||||||||||||||||||||||||
|
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 1 the reactor is "signal-safe" when dispatching handlers to signal events, whereas if <mask_signals> is 0 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). |
|
||||||||||||||||||||||||||||||||||||||||
|
|
|
||||||||||
|
Close down the select_reactor and release all of its resources.
|
|
||||||||||
|
Deny access since member-wise won't work...
|
|
||||||||||
|
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Implements ACE_Reactor_Impl. |
|
||||||||||
|
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. |
|
||||||||||
|
Implement the <any_ready> method, assuming that the Sig_Guard is beign held |
|
||||||||||||||||||||
|
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. Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||||||||
|
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. Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||||||||
|
CLR the dispatch MASK "bit" bound with the <handle> and the <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||
|
CLR the dispatch MASK "bit" bound with the <eh> and the <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Make sure the handles are all valid.
|
|
||||||||||
|
Close down the select_reactor and release all of its resources.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||
|
Returns -1 (not used in this implementation);.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
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. |
|
||||||||||
|
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. |
|
||||||||||||||||
|
Template Method that dispatches <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. |
|
||||||||||||||||||||
|
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. |
|
||||||||||||||||||||||||||||||||
|
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. |
|
||||||||||||||||||||
|
Dispatch any notification handlers. Returns -1 if the state of the <wait_set_> has changed, else returns number of handlers notified. |
|
||||||||||
|
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. |
|
||||||||||
|
Dump the state of an object.
Implements ACE_Reactor_Impl. Reimplemented in ACE_Priority_Reactor. |
|
||||||||||
|
Return the Event_Handler associated with <handle>. Return 0 if <handle> is not registered. Implements ACE_Reactor_Impl. |
|
||||||||||
|
Implement the public <handler> method.
|
|
||||||||||
|
Take corrective action when errors occur.
|
|
||||||||||
|
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. |
|
||||||||||
|
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. |
|
||||||||||
|
Stops the VC++ compiler from bitching about exceptions and destructors.
|
|
||||||||||||||||
|
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. |
|
||||||||||||||||||||
|
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. |
|
||||||||||||||||
|
Implement the public <handler> method.
|
|
||||||||||||||||||||
|
Implement the public <handler> method.
|
|
||||||||||
|
Returns true if we've been successfully initialized, else false.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Check to see if the <Event_Handler> associated with <handle> is suspended. Returns 0 if not, 1 if so. Implements ACE_Select_Reactor_Impl. |
|
||||||||||
|
Returns a reference to the <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. Implements ACE_Reactor_Impl. |
|
||||||||||||||||||||
|
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle> and <mask>. Implements ACE_Reactor_Impl. |
|
||||||||||||||||||||
|
GET/SET/ADD/CLR the dispatch mask "bit" bound with the <eh> and <mask>. Implements ACE_Reactor_Impl. |
|
||||||||||
|
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. |
|
||||||||||
|
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. |
|
||||||||||||||||||||
|
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. |
|
||||||||||||||||||||||||||||
|
Notify the appropriate <callback> in the context of the <eh> associated with <handle> that a particular event has occurred. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||||||||||||||
|
Initialize the
Implements ACE_Reactor_Impl. |
|
||||||||||
|
|
|
||||||||||
|
Return the current owner of the thread.
Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||
|
Set the new owner of the thread and return the old owner.
Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||
|
GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||||||
|
GET/SET/ADD/CLR the ready "bit" bound with the <eh> and <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||||||
|
Registers <new_sh> to handle a set of signals <sigset> using the <new_disp>. Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||||||||||
|
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. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||
|
Register <eh> with all the <handles> in the <Handle_Set>.
Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||||||
|
Not implemented.
Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||
|
Not implemented.
Implements ACE_Reactor_Impl. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||
|
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. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||
|
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. Reimplemented in ACE_TP_Reactor. |
|
||||||||||||||||||||
|
Register a set of <handles>.
Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||||||||||||
|
Do the work of actually binding the <handle> and <eh> with the <mask>. Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||
|
Release the token lock when a Win32 structured exception occurs.
|
|
||||||||||
|
Calls <remove_handler> for every signal in <sigset>.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||||||||||
|
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. |
|
||||||||||||||||
|
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. |
|
||||||||||||||||
|
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. |
|
||||||||||||||||
|
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. |
|
||||||||||||||||
|
Remove a set of <handles>.
Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||||||||
|
Do the work of actually unbinding the <handle> and <eh> with the <mask>. Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||
|
Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>. Implements ACE_Select_Reactor_Impl. |
|
||||||||||
|
Get position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback. Implements ACE_Reactor_Impl. |
|
||||||||||
|
Set position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback. Implements ACE_Reactor_Impl. |
|
||||||||||||||||
|
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. Reimplemented in ACE_FlReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||
|
Set a new value for restart and return the original value.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Get the existing restart value.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Resume all <handles> in handle set.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Resume a temporarily suspended <Event_Handler> associated with <handle>. Implements ACE_Reactor_Impl. |
|
||||||||||
|
Resume a temporarily suspend <Event_Handler> associated with <eh>. Implements ACE_Reactor_Impl. |
|
||||||||||
|
Resume all the <Event_Handlers> in the Select_Reactor.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Resume the <Event_Handler> associated with <handle>.
|
|
||||||||||||||||||||||||
|
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.
Implements ACE_Reactor_Impl. Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||||||||
|
ADD the dispatch MASK "bit" bound with the <handle> and the <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||||||||
|
ADD the dispatch MASK "bit" bound with the <eh> and the <mask>.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Use a user specified signal handler instead.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Returns the current size of the Reactor's internal descriptor table. Implements ACE_Reactor_Impl. |
|
||||||||||
|
Suspend all <handles> in handle set temporarily.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Temporarily suspend the <Event_Handler> associated with <handle>.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Temporarily suspend the <Event_Handler> associated with <eh>.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Suspend all the <Event_Handlers> in the Select_Reactor.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Suspend the <Event_Handler> associated with <handle>.
|
|
||||||||||
|
Return the current <ACE_Timer_Queue>.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Set a user-specified timer queue.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. Since the Select_Reactor does not do any event associations, this function always return 0. Implements ACE_Reactor_Impl. |
|
||||||||||||||||
|
Wait for events to occur.
Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor. |
|
||||||||||
|
Wake up all threads in waiting in the event loop.
Implements ACE_Reactor_Impl. |
|
||||||||||
|
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. |
|
|||||
|
Declare the dynamic allocation hooks.
Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_Priority_Reactor, and ACE_TP_Reactor. |
|
|||||
|
This flag is used to keep track of whether we are actively handling events or not. |
|
|||||
|
Adapter used to return internal lock to outside world.
|
|
|||||
|
If 0 then the Reactor will not mask the signals during the event dispatching. This is useful for applications that do not register any signal handlers and want to reduce the overhead introduce by the kernel level locks required to change the mask. |
|
|||||
|
Synchronization token for the MT_SAFE ACE_Select_Reactor.
|
1.2.18