ACE
6.1.4
|
A `/dev/poll' or `/dev/epoll' based Reactor implemenatation. More...
#include <Dev_Poll_Reactor.h>
Classes | |
struct | Event_Tuple |
Struct that collects event registration information for a handle. More... | |
class | Handler_Repository |
Used to map ACE_HANDLEs onto the appropriate Event_Tuple. More... | |
class | Token_Guard |
A helper class that helps grabbing, releasing and waiting on tokens for a thread that needs access to the reactor's token. More... | |
Public Member Functions | |
ACE_Dev_Poll_Reactor (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_DEV_POLL_TOKEN::FIFO) | |
Initialize ACE_Dev_Poll_Reactor with the default size. | |
ACE_Dev_Poll_Reactor (size_t size, bool restart=false, 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_DEV_POLL_TOKEN::FIFO) | |
Initialize ACE_Dev_Poll_Reactor with size size. | |
virtual | ~ACE_Dev_Poll_Reactor (void) |
Close down and release all resources. | |
virtual int | open (size_t size, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *=0) |
Initialization. | |
virtual int | current_info (ACE_HANDLE handle, size_t &) |
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 |
virtual int | close (void) |
Close down and release all 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 *event_handler, ACE_Reactor_Mask mask) |
virtual int | register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
virtual int | register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
virtual int | register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
virtual int | register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0) |
virtual int | register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0) |
virtual int | remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Removes event_handler. | |
virtual int | remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
virtual int | remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask 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 *event_handler) |
virtual int | suspend_handler (ACE_HANDLE handle) |
Suspend handle temporarily. | |
virtual int | suspend_handler (const ACE_Handle_Set &handles) |
Suspend all handles in handle set temporarily. | |
virtual int | suspend_handlers (void) |
Suspend all handles temporarily. | |
virtual int | resume_handler (ACE_Event_Handler *event_handler) |
virtual int | resume_handler (ACE_HANDLE handle) |
Resume handle. | |
virtual int | resume_handler (const ACE_Handle_Set &handles) |
Resume all handles in handle set. | |
virtual int | resume_handlers (void) |
Resume all handles. | |
virtual int | resumable_handler (void) |
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 *event_handler, ACE_Reactor_Mask masks_to_be_added) |
virtual int | schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added) |
virtual int | cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared) |
Clear masks_to_be_cleared from the event_handler's entry. | |
virtual int | cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared) |
Clear masks_to_be_cleared from the handle's entry. | |
virtual int | notify (ACE_Event_Handler *event_handler=0, ACE_Reactor_Mask mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0) |
virtual void | max_notify_iterations (int) |
virtual int | max_notify_iterations (void) |
virtual int | purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK) |
virtual ACE_Event_Handler * | find_handler (ACE_HANDLE handle) |
virtual int | handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0) |
virtual int | handler (int signum, ACE_Event_Handler **=0) |
virtual bool | initialized (void) |
virtual size_t | size (void) const |
virtual ACE_Lock & | lock (void) |
Returns a reference to the Reactor's internal lock. | |
virtual void | wakeup_all_threads (void) |
Wake up all threads waiting in the event loop. | |
virtual int | owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0) |
Transfers ownership of Reactor_Impl to the new_owner. | |
virtual int | owner (ACE_thread_t *owner) |
Return the ID of the "owner" thread. | |
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) |
Set position of the owner thread. | |
virtual int | requeue_position (void) |
Get position of the owner thread. | |
virtual void | dump (void) const |
Dump the state of an object. | |
Low-level wait_set mask manipulation methods | |
Low-level methods to manipulate the event/reactor mask associated with a handle and event handler when polling for events.
| |
virtual int | mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops) |
virtual int | mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops) |
Low-level ready_set mask manipulation methods | |
These methods are unimplemented. | |
virtual int | ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops) |
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. | |
Public Member Functions inherited from ACE_Reactor_Impl | |
virtual | ~ACE_Reactor_Impl (void) |
Close down and release all resources. | |
virtual int | register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)=0 |
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 Member Functions | |
int | work_pending_i (ACE_Time_Value *max_wait_time) |
Non-locking version of wait_pending(). | |
int | handle_events_i (ACE_Time_Value *max_wait_time, Token_Guard &guard) |
int | upcall (ACE_Event_Handler *event_handler, int(ACE_Event_Handler::*callback)(ACE_HANDLE), ACE_HANDLE handle) |
Perform the upcall with the given event handler method. | |
int | dispatch (Token_Guard &guard) |
int | dispatch_timer_handler (Token_Guard &guard) |
int | dispatch_io_event (Token_Guard &guard) |
int | register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *eh, ACE_Reactor_Mask mask) |
Register the given event handler with the reactor. | |
int | remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler *eh=0) |
int | suspend_handler_i (ACE_HANDLE handle) |
Temporarily remove the given handle from the "interest set.". | |
int | resume_handler_i (ACE_HANDLE handle) |
int | mask_ops_i (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops) |
short | reactor_mask_to_poll_event (ACE_Reactor_Mask mask) |
Convert a reactor mask to its corresponding poll() event mask. | |
Protected Attributes | |
bool | initialized_ |
Has the reactor been initialized. | |
ACE_HANDLE | poll_fd_ |
struct pollfd * | dp_fds_ |
The pollfd array that `/dev/poll' will feed its results to. | |
struct pollfd * | start_pfds_ |
struct pollfd * | end_pfds_ |
The last element in the pollfd array plus one. | |
sig_atomic_t | deactivated_ |
ACE_Dev_Poll_Reactor_Token | token_ |
Lock used for synchronization of reactor state. | |
ACE_Lock_Adapter < ACE_Dev_Poll_Reactor_Token > | lock_adapter_ |
Adapter used to return internal lock to outside world. | |
Handler_Repository | handler_rep_ |
The repository that contains all registered event handlers. | |
ACE_Timer_Queue * | timer_queue_ |
Defined as a pointer to allow overriding by derived classes... | |
bool | delete_timer_queue_ |
ACE_Sig_Handler * | signal_handler_ |
Handle signals without requiring global/static variables. | |
bool | delete_signal_handler_ |
ACE_Reactor_Notify * | notify_handler_ |
bool | delete_notify_handler_ |
int | mask_signals_ |
bool | restart_ |
A `/dev/poll' or `/dev/epoll' based Reactor implemenatation.
The ACE_Dev_Poll_Reactor uses the `/dev/poll' or '/dev/epoll' character devices to demultiplex events on a given set of file descriptors. Unlike select()
, `/dev/poll' and `/dev/epoll' have no hard-coded limit on the number of file descriptors that may be handled at any given time. As such, the ACE_Dev_Poll_Reactor can generally handle a much larger number of file descriptors than select()
-based reactors. Furthermore, since `/dev/poll' and `/dev/epoll' both return a set of file descriptors that are active, there is no need to "walk" the set of file descriptors to determine which ones are active, such as what is done with the select()
and poll()
system calls. All returned file descriptors are active. This makes event dispatching very efficient.
ACE_Dev_Poll_Reactor
. However, the timeout resolution for timers is independent of the reactors timeout resolution. As such, it may be possible to achieve sub-millisecond timeout resolutions for timers but that is entirely platform dependent. ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor | ( | ACE_Sig_Handler * | sh = 0 , |
ACE_Timer_Queue * | tq = 0 , |
||
int | disable_notify_pipe = 0 , |
||
ACE_Reactor_Notify * | notify = 0 , |
||
int | mask_signals = 1 , |
||
int | s_queue = ACE_DEV_POLL_TOKEN::FIFO |
||
) |
Initialize ACE_Dev_Poll_Reactor
with the default size.
The default size for the ACE_Dev_Poll_Reactor
is the maximum number of open file descriptors for the process.
ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor | ( | size_t | size, |
bool | restart = false , |
||
ACE_Sig_Handler * | sh = 0 , |
||
ACE_Timer_Queue * | tq = 0 , |
||
int | disable_notify_pipe = 0 , |
||
ACE_Reactor_Notify * | notify = 0 , |
||
int | mask_signals = 1 , |
||
int | s_queue = ACE_DEV_POLL_TOKEN::FIFO |
||
) |
Initialize ACE_Dev_Poll_Reactor with size size.
|
virtual |
Close down and release all resources.
|
virtual |
Implements ACE_Reactor_Impl.
|
virtual |
Implements ACE_Reactor_Impl.
|
virtual |
Cancel all Event_Handlers that match the address of event_handler. Returns number of handlers cancelled.
Implements ACE_Reactor_Impl.
|
virtual |
Cancel the single 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. Returns 1 if cancellation succeeded and 0 if the timer_id wasn't found.
Implements ACE_Reactor_Impl.
|
virtual |
Clear masks_to_be_cleared from the event_handler's entry.
Implements ACE_Reactor_Impl.
|
virtual |
Clear masks_to_be_cleared from the handle's entry.
Implements ACE_Reactor_Impl.
|
virtual |
Close down and release all resources.
Implements ACE_Reactor_Impl.
|
virtual |
handle | allows the reactor to check if the caller is valid. |
Implements ACE_Reactor_Impl.
|
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 desired.
Implements ACE_Reactor_Impl.
|
virtual |
handle_events()
and handle_alertable_events()
return -1 immediately. Implements ACE_Reactor_Impl.
|
protected |
Dispatch 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.
|
protected |
Dispatch an IO event to the corresponding event handler. Returns Returns: 0 if no events ready (token still held), 1 if an event was expired (token released), -1 on error (token still held).
|
protected |
Dispatch a single timer, if ready. Returns: 0 if no timers ready (token still held), 1 if a timer was expired (token released), -1 on error (token still held).
|
virtual |
Dump the state of an object.
Implements ACE_Reactor_Impl.
|
virtual |
Return the Event_Handler associated with handle. Return 0 if handle is not registered.
Implements ACE_Reactor_Impl.
|
virtual |
This event loop driver blocks for up to max_wait_time before returning. It will return earlier if events occur. Note that max_wait_time can be 0, in which case this method blocks indefinitely until events occur.
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. alertable_handle_events()
and handle_events() is that in the alertable case, the event loop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.ACE_Event_Handlers
that were dispatched, 0 if the max_wait_time elapsed without dispatching any handlers, or -1 if an error occurs.ACE_Dev_Poll_Reactor
. Implements ACE_Reactor_Impl.
|
virtual |
This method is just like the one above, except the max_wait_time value is a reference and can therefore never be NULL
.
ACE_Dev_Poll_Reactor
. Implements ACE_Reactor_Impl.
|
protected |
Poll for events and return the number of event handlers that were dispatched. This is a helper method called by all handle_events() methods.
|
virtual |
Check to see if handle is associated with a valid Event_Handler bound to mask. Return the event_handler associated with this handler
if event_handler != 0.
Implements ACE_Reactor_Impl.
|
virtual |
Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the event_handler associated with this handler
if event_handler != 0.
Implements ACE_Reactor_Impl.
|
virtual |
Returns true if Reactor has been successfully initialized, else false.
Implements ACE_Reactor_Impl.
|
virtual |
Returns a reference to the Reactor's internal lock.
Implements ACE_Reactor_Impl.
|
virtual |
GET/SET/ADD/CLR the dispatch mask "bit" bound with the event_handler and mask.
Implements ACE_Reactor_Impl.
|
virtual |
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.
Implements ACE_Reactor_Impl.
|
protected |
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask. This internal helper method acquires no lock.
Reset the mask for the given handle.
|
virtual |
Set the maximum number of times that ACE_Reactor_Impl will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. By default, this is set to -1, which means "iterate until the queue 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.
|
virtual |
Get the maximum number of times that the ACE_Reactor_Impl will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop.
Implements ACE_Reactor_Impl.
|
virtual |
Notify event_handler of mask event. The ACE_Time_Value indicates how long to blocking trying to notify. 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.
|
virtual |
Initialization.
Implements ACE_Reactor_Impl.
|
virtual |
Transfers ownership of Reactor_Impl to the new_owner.
Implements ACE_Reactor_Impl.
|
virtual |
Return the ID of the "owner" thread.
Implements ACE_Reactor_Impl.
|
virtual |
Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. Returns the number of notifications purged. Returns -1 on error.
Implements ACE_Reactor_Impl.
|
protected |
Convert a reactor mask to its corresponding poll() event mask.
|
virtual |
GET/SET/ADD/CLR the ready "bit" bound with the event_handler and mask.
Implements ACE_Reactor_Impl.
|
virtual |
GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.
Implements ACE_Reactor_Impl.
|
virtual |
Register event_handler with mask. The I/O handle will always come from get_handle on the event_handler.
Implements ACE_Reactor_Impl.
|
virtual |
Register event_handler with mask. The I/O handle is provided through the io_handle parameter.
Implements ACE_Reactor_Impl.
|
virtual |
Register an event_handler that will be notified when event_handle is signaled. mask specifies the network events that the event_handler is interested in.
Implements ACE_Reactor_Impl.
|
virtual |
Register event_handler with all the handles in the Handle_Set
.
Implements ACE_Reactor_Impl.
|
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.
|
virtual |
Registers new_sh to handle a set of signals sigset using the new_disp.
Implements ACE_Reactor_Impl.
|
protected |
Register the given event handler with the reactor.
|
virtual |
Removes event_handler.
get_handle()
method of event_handler . If mask == ACE_Event_Handler::DONT_CALL
then the handle_close()
method of the event_handler is not invoked. Implements ACE_Reactor_Impl.
|
virtual |
Removes handle. If mask == ACE_Event_Handler::DONT_CALL then the <handle_close> method of the associated <event_handler> is not invoked.
Implements ACE_Reactor_Impl.
|
virtual |
Removes all handles in handle_set. If mask == ACE_Event_Handler::DONT_CALL then the <handle_close> method of the associated <event_handler>s is not invoked.
Implements ACE_Reactor_Impl.
|
virtual |
Remove the ACE_Event_Handler currently associated with signum. 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.
|
virtual |
Calls <remove_handler> for every signal in sigset.
Implements ACE_Reactor_Impl.
|
protected |
Remove the event handler associated with the given handle and event mask from the "interest set." If eh is supplied, only do the remove if matches the event handler that's registered for handle.
|
virtual |
|
virtual |
|
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.
|
virtual |
Get the existing restart value.
Implements ACE_Reactor_Impl.
|
virtual |
Set a new value for restart and return the original value.
r | If zero, then the event loop will not be automatically restarted if the underlying poll is interrupted via the INTR (interrupt) signal. |
Implements ACE_Reactor_Impl.
|
virtual |
Does the reactor allow the application to resume the handle on its own, i.e., can it pass on the control of handle resumption to the application.
Implements ACE_Reactor_Impl.
|
virtual |
Resume event_handler. Use ACE_Event_Handler::get_handle() to get the handle.
Implements ACE_Reactor_Impl.
|
virtual |
Resume handle.
Implements ACE_Reactor_Impl.
|
virtual |
Resume all handles in handle set.
Implements ACE_Reactor_Impl.
|
protected |
Place the given handle that was temporarily removed from the "interest set," i.e that was suspended, back in to the interest set. The given handle will once again be polled for events.
|
virtual |
Resume all handles.
Implements ACE_Reactor_Impl.
|
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 for which the timer will be automatically rescheduled. |
Implements ACE_Reactor_Impl.
|
virtual |
Add masks_to_be_added to the event_handler's entry. event_handler must already have been registered.
Implements ACE_Reactor_Impl.
|
virtual |
Add masks_to_be_added to the handle's entry. <event_handler> associated with handle must already have been registered.
Implements ACE_Reactor_Impl.
|
virtual |
Use a user specified signal handler instead.
Implements ACE_Reactor_Impl.
|
virtual |
Returns the current size of the Reactor's internal descriptor table.
Implements ACE_Reactor_Impl.
|
virtual |
Suspend event_handler temporarily. Use ACE_Event_Handler::get_handle() to get the handle.
Implements ACE_Reactor_Impl.
|
virtual |
Suspend handle temporarily.
Implements ACE_Reactor_Impl.
|
virtual |
Suspend all handles in handle set temporarily.
Implements ACE_Reactor_Impl.
|
protected |
Temporarily remove the given handle from the "interest set.".
|
virtual |
Suspend all handles temporarily.
Implements ACE_Reactor_Impl.
|
virtual |
Set a user-specified timer queue.
Implements ACE_Reactor_Impl.
|
virtual |
|
inlineprotected |
Perform the upcall with the given event handler method.
|
virtual |
Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise.
Implements ACE_Reactor_Impl.
|
virtual |
Wake up all threads waiting in the event loop.
Implements ACE_Reactor_Impl.
|
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".
ACE_Dev_Poll_Reactor
. Implements ACE_Reactor_Impl.
|
protected |
Non-locking version of wait_pending().
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".
ACE_Dev_Poll_Reactor::ACE_ALLOC_HOOK_DECLARE |
Declare the dynamic allocation hooks.
|
protected |
This flag is used to keep track of whether we are actively handling events or not.
|
protected |
Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it).
|
protected |
Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).
|
protected |
Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).
|
protected |
The pollfd array that `/dev/poll' will feed its results to.
|
protected |
The last element in the pollfd array plus one.
The loop that dispatches IO events stops when this->start_pfds == this->end_pfds_.
|
protected |
The repository that contains all registered event handlers.
|
protected |
Has the reactor been initialized.
|
protected |
Adapter used to return internal lock to outside world.
|
protected |
Flag that determines if signals are masked during event dispatching. 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.
|
protected |
Callback object that unblocks the <ACE_Select_Reactor> if it's sleeping.
|
protected |
The file descriptor associated with the open `/dev/poll' or `/dev/epoll' device. All interactions with the `/dev/poll' or `/dev/epoll' device are done through this file descriptor.
|
protected |
Restart the handle_events event loop method automatically when polling function in use (ioctl() in this case) is interrupted via an EINTR signal.
|
protected |
Handle signals without requiring global/static variables.
|
protected |
Pointer to the next pollfd array element that contains the next event to be dispatched.
|
protected |
Defined as a pointer to allow overriding by derived classes...
|
protected |
Lock used for synchronization of reactor state.