An object oriented event demultiplexor and event handler dispatcher. More...
#include <Select_Reactor_T.h>
Public Attributes | |
| ACE_ALLOC_HOOK_DECLARE | |
| Declare the dynamic allocation hooks. | |
 Public Attributes inherited from ACE_Reactor_Impl | |
| ACE_ALLOC_HOOK_DECLARE | |
| Declare the dynamic allocation hooks. | |
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_ |
| Protected Attributes inherited from ACE_Select_Reactor_Impl | |
| ACE_Select_Reactor_Handler_Repository | handler_rep_ |
| Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s. | |
| ACE_Select_Reactor_Handle_Set | dispatch_set_ |
| Tracks handles that are ready for dispatch from <select> | |
| ACE_Select_Reactor_Handle_Set | wait_set_ |
| Tracks handles that are waited for by <select>. | |
| ACE_Select_Reactor_Handle_Set | suspend_set_ |
| Tracks handles that are currently suspended. | |
| ACE_Select_Reactor_Handle_Set | ready_set_ |
| ACE_Timer_Queue * | timer_queue_ |
| Defined as a pointer to allow overriding by derived classes... | |
| ACE_Sig_Handler * | signal_handler_ |
| Handle signals without requiring global/static variables. | |
| ACE_Reactor_Notify * | notify_handler_ |
| bool | delete_timer_queue_ |
| bool | delete_signal_handler_ |
| bool | delete_notify_handler_ |
| bool | initialized_ |
| True if we've been initialized yet... | |
| bool | restart_ |
| int | requeue_position_ |
| ACE_thread_t | owner_ |
| The original thread that created this Select_Reactor. | |
| bool | state_changed_ |
| bool | mask_signals_ |
Private Member Functions | |
| ACE_Select_Reactor_T (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)=delete | |
| ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > & | operator= (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)=delete |
Additional Inherited Members | |
| Public Types inherited from ACE_Select_Reactor_Impl | |
| enum | { DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE } |
Detailed Description
An object oriented event demultiplexor and event handler dispatcher.
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.
Constructor & Destructor Documentation
◆ ACE_Select_Reactor_T() [1/3]
| 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 ) |
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() [2/3]
| 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 ) |
Initialize ACE_Select_Reactor with size
- size. 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 notification 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).
- Note
- On Unix platforms, the size parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons.
◆ ~ACE_Select_Reactor_T()
|
virtual |
Close down the select_reactor and release all of its resources.
◆ ACE_Select_Reactor_T() [3/3]
|
privatedelete |
Member Function Documentation
◆ alertable_handle_events() [1/2]
|
inlinevirtual |
Implements ACE_Reactor_Impl.
◆ alertable_handle_events() [2/2]
|
inlinevirtual |
Implements ACE_Reactor_Impl.
◆ any_ready()
|
protectedvirtual |
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.
◆ any_ready_i()
|
protectedvirtual |
Implement the <any_ready> method, assuming that the Sig_Guard is being held
◆ cancel_timer() [1/2]
|
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.
◆ cancel_timer() [2/2]
|
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.
◆ cancel_wakeup() [1/2]
|
inlinevirtual |
CLR the dispatch MASK "bit" bound with the eh and the mask.
Implements ACE_Reactor_Impl.
◆ cancel_wakeup() [2/2]
|
inlinevirtual |
CLR the dispatch MASK "bit" bound with the handle and the mask.
Implements ACE_Reactor_Impl.
◆ check_handles()
|
protectedvirtual |
Make sure the handles are all valid.
◆ close()
|
virtual |
Close down the select_reactor and release all of its resources.
Implements ACE_Reactor_Impl.
◆ current_info()
|
virtual |
Returns -1 (not used in this implementation);.
Implements ACE_Reactor_Impl.
◆ deactivate()
|
inlinevirtual |
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.
◆ deactivated()
|
inlinevirtual |
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.
◆ dispatch()
|
protectedvirtual |
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.
◆ dispatch_io_handlers()
|
protectedvirtual |
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.
◆ dispatch_io_set()
|
protectedvirtual |
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_notification_handlers()
|
protectedvirtual |
Dispatch any notification handlers. Returns -1 if the state of the <wait_set_> has changed, else returns number of handlers notified.
◆ dispatch_timer_handlers()
|
protectedvirtual |
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()
|
virtual |
◆ find_handler()
|
virtual |
Return the Event_Handler associated with handle. Return 0 if handle is not registered.
Implements ACE_Reactor_Impl.
◆ find_handler_i()
|
protectedvirtual |
Implement the public handler method.
◆ handle_error()
|
protectedvirtual |
Take corrective action when errors occur.
◆ handle_events() [1/2]
|
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.
◆ handle_events() [2/2]
|
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.
◆ handle_events_i()
|
protected |
Stops the VC++ compiler from bitching about exceptions and destructors.
◆ handler() [1/2]
|
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.
◆ handler() [2/2]
|
inlinevirtual |
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.
◆ handler_i() [1/2]
|
protectedvirtual |
Implement the public handler method.
◆ handler_i() [2/2]
|
protectedvirtual |
Implement the public handler method.
◆ initialized()
|
virtual |
Returns true if we've been successfully initialized, else false.
Implements ACE_Reactor_Impl.
◆ is_suspended_i()
|
protectedvirtual |
Check to see if the <Event_Handler> associated with handle is suspended. Returns 0 if not, 1 if so.
Implements ACE_Select_Reactor_Impl.
◆ lock()
|
inlinevirtual |
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.
◆ mask_ops() [1/2]
|
inlinevirtual |
GET/SET/ADD/CLR the dispatch mask "bit" bound with the eh and mask.
Implements ACE_Reactor_Impl.
◆ mask_ops() [2/2]
|
virtual |
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.
Implements ACE_Reactor_Impl.
◆ max_notify_iterations() [1/2]
|
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.
◆ max_notify_iterations() [2/2]
|
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.
◆ notify()
|
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.
◆ notify_handle()
|
protectedvirtual |
Notify the appropriate callback in the context of the eh associated with handle that a particular event has occurred.
Reimplemented in ACE_TP_Reactor.
◆ open()
|
virtual |
Initialize the ACE_Select_Reactor to manage
- max_number_of_handles. If
- restart is non-0 then the
ACE_Reactor'shandle_eventsmethod will be restarted automatically whenEINTRoccurs. If - signal_handler or
- timer_queue are non-0 they are used as the signal handler and timer queue, respectively. If
- disable_notify_pipe is non-0 the notification pipe is not created, thereby saving two I/O handles.
- Note
- On Unix platforms, the maximum_number_of_handles parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons.
Implements ACE_Reactor_Impl.
◆ operator=()
|
privatedelete |
◆ owner() [1/2]
|
virtual |
Return the current owner of the thread.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
◆ owner() [2/2]
|
virtual |
Set the new owner of the thread and return the old owner.
Implements ACE_Reactor_Impl.
Reimplemented in ACE_TP_Reactor.
◆ ready_ops() [1/2]
|
inlinevirtual |
GET/SET/ADD/CLR the ready "bit" bound with the eh and mask.
Implements ACE_Reactor_Impl.
◆ ready_ops() [2/2]
|
virtual |
GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.
Implements ACE_Reactor_Impl.
◆ register_handler() [1/7]
|
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.
◆ register_handler() [2/7]
|
inlinevirtual |
Not implemented.
Implements ACE_Reactor_Impl.
◆ register_handler() [3/7]
|
inlinevirtual |
Not implemented.
Implements ACE_Reactor_Impl.
◆ register_handler() [4/7]
|
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.
◆ register_handler() [5/7]
|
virtual |
Register eh with all the handles in the <Handle_Set>.
Implements ACE_Reactor_Impl.
◆ register_handler() [6/7]
|
virtual |
Registers new_sh to handle a set of signals sigset using the new_disp.
Implements ACE_Reactor_Impl.
◆ register_handler() [7/7]
|
inlinevirtual |
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.
◆ register_handler_i() [1/2]
|
protectedvirtual |
Do the work of actually binding the handle and eh with the mask.
◆ register_handler_i() [2/2]
|
protectedvirtual |
Register a set of handles.
◆ release_token()
|
protected |
Release the token lock when a Win32 structured exception occurs.
◆ remove_handler() [1/5]
|
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.
◆ remove_handler() [2/5]
|
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.
◆ remove_handler() [3/5]
|
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.
◆ remove_handler() [4/5]
|
virtual |
Calls <remove_handler> for every signal in sigset.
Implements ACE_Reactor_Impl.
◆ remove_handler() [5/5]
|
inlinevirtual |
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.
◆ remove_handler_i() [1/2]
|
protectedvirtual |
Do the work of actually unbinding the handle and eh with the mask.
◆ remove_handler_i() [2/2]
|
protectedvirtual |
Remove a set of handles.
◆ renew()
|
protectedvirtual |
Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>.
Implements ACE_Select_Reactor_Impl.
◆ requeue_position() [1/2]
|
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.
◆ requeue_position() [2/2]
|
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.
◆ reset_timer_interval()
|
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.
◆ restart() [1/2]
|
virtual |
Get the existing restart value.
Implements ACE_Reactor_Impl.
◆ restart() [2/2]
|
virtual |
Set a new value for restart and return the original value.
Implements ACE_Reactor_Impl.
◆ resume_handler() [1/3]
|
inlinevirtual |
Resume a temporarily suspend Event_Handler associated with eh.
Implements ACE_Reactor_Impl.
◆ resume_handler() [2/3]
|
virtual |
Resume a temporarily suspended Event_Handler associated with handle.
Implements ACE_Reactor_Impl.
◆ resume_handler() [3/3]
|
inlinevirtual |
Resume all handles in handle set.
Implements ACE_Reactor_Impl.
◆ resume_handlers()
|
virtual |
Resume all the <Event_Handlers> in the Select_Reactor.
Implements ACE_Reactor_Impl.
◆ resume_i()
|
protectedvirtual |
Resume the <Event_Handler> associated with handle.
◆ schedule_timer()
|
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.
- See also
- cancel_timer()
- reset_timer_interval()
- Parameters
-
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
- Returns
- -1 on failure, a timer_id value on success
Implements ACE_Reactor_Impl.
◆ schedule_wakeup() [1/2]
|
inlinevirtual |
ADD the dispatch MASK "bit" bound with the eh and the mask.
Implements ACE_Reactor_Impl.
◆ schedule_wakeup() [2/2]
|
inlinevirtual |
ADD the dispatch MASK "bit" bound with the handle and the mask.
Implements ACE_Reactor_Impl.
◆ set_sig_handler()
|
virtual |
Use a user specified signal handler instead.
Implements ACE_Reactor_Impl.
◆ size()
|
inlinevirtual |
Returns the current size of the Reactor's internal descriptor table.
Implements ACE_Reactor_Impl.
◆ suspend_handler() [1/3]
|
inlinevirtual |
Temporarily suspend the <Event_Handler> associated with eh.
Implements ACE_Reactor_Impl.
◆ suspend_handler() [2/3]
|
virtual |
Temporarily suspend the Event_Handler associated with handle.
Implements ACE_Reactor_Impl.
◆ suspend_handler() [3/3]
|
inlinevirtual |
Suspend all handles in handle set temporarily.
Implements ACE_Reactor_Impl.
◆ suspend_handlers()
|
virtual |
Suspend all the <Event_Handlers> in the Select_Reactor.
Implements ACE_Reactor_Impl.
◆ suspend_i()
|
protectedvirtual |
Suspend the <Event_Handler> associated with handle.
◆ timer_queue() [1/2]
|
virtual |
Return the current ACE_Timer_Queue.
Implements ACE_Reactor_Impl.
◆ timer_queue() [2/2]
|
virtual |
Set a user-specified timer queue.
Implements ACE_Reactor_Impl.
◆ uses_event_associations()
|
inlinevirtual |
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.
◆ wait_for_multiple_events()
|
protectedvirtual |
Wait for events to occur.
◆ wakeup_all_threads()
|
inlinevirtual |
Wake up all threads in waiting in the event loop.
Implements ACE_Reactor_Impl.
◆ work_pending()
|
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.
Member Data Documentation
◆ ACE_ALLOC_HOOK_DECLARE
| ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_ALLOC_HOOK_DECLARE |
Declare the dynamic allocation hooks.
◆ deactivated_
|
protected |
This flag is used to keep track of whether we are actively handling events or not.
◆ lock_adapter_
|
protected |
Adapter used to return internal lock to outside world.
◆ token_
|
protected |
Synchronization token for the MT_SAFE ACE_Select_Reactor.
The documentation for this class was generated from the following files:
