#include <Select_Reactor_T.h>
Inheritance diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:
Public Member Functions | |
| 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 | 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 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_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. |
|
||||||||||
|
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.
|
|
|||||
|
Synchronization token for the MT_SAFE ACE_Select_Reactor.
|
1.3.9.1