---

ACE_Dev_Poll_Reactor Class Reference

A `/dev/poll' or `/dev/epoll' based Reactor implemenatation. More...

#include <Dev_Poll_Reactor.h>

Inheritance diagram for ACE_Dev_Poll_Reactor:

[legend]Collaboration diagram for ACE_Dev_Poll_Reactor:

[legend]List of all members.

Public Methods
	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)
	Initialize ACE_Dev_Poll_Reactor with the default size.
	ACE_Dev_Poll_Reactor (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)
	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, int restart=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *=0)
	Initialization.
virtual int	current_info (ACE_HANDLE, size_t &)
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)
	Set a user specified timer queue.
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 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)
	Register <event_handler> 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 *event_handler, ACE_Reactor_Mask mask)
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 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 *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 int	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 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)
	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. The "interest set," i.e. the wait set, can be directly manipulated with these methods.
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 Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Methods
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)
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 (void)
int	dispatch_timer_handlers (int &number_of_handlers_dispatched)
int	dispatch_io_events (int &io_handlers_dispatched)
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)
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
char	initialized_
	Has the reactor been initialized.
ACE_HANDLE	poll_fd_
size_t	size_
char *	mmap_
	The memory map that `/dev/epoll' will feed its results to.
pollfd *	start_pfds_
pollfd *	end_pfds_
	The last element in the pollfd array plus one.
sig_atomic_t	deactivated_
ACE_SYNCH_MUTEX	lock_
	Lock used for synchronization of reactor state.
ACE_Lock_Adapter< ACE_SYNCH_MUTEX >	lock_adapter_
	Adapter used to return internal lock to outside world.
ACE_Dev_Poll_Reactor_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...
int	delete_timer_queue_
ACE_Sig_Handler *	signal_handler_
	Handle signals without requiring global/static variables.
int	delete_signal_handler_
ACE_Reactor_Notify *	notify_handler_
int	delete_notify_handler_
int	mask_signals_
int	restart_

---

Detailed Description

A `/dev/poll' or `/dev/epoll' based Reactor implemenatation.

Note:

This reactor is EXPERIMENTAL.

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.

Note:

In general, this reactor may only be used to demultiplex events on sockets. Demultiplexing events on pipes, for example may not work. This is due to a limitation in the underlying `/dev/poll' device driver.

Note:

It is only possible to achieve millisecond timeout resolutions with the 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.

---

Constructor & Destructor Documentation

ACE_Dev_Poll_Reactor::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 )

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, 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 )

Initialize ACE_Dev_Poll_Reactor with size "size.". 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. If the size parameter is less than the process maximum, then the process maximum will be decreased in order to prevent potential access violations.

ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor (  void    )  [virtual]

Close down and release all resources.

---

Member Function Documentation

int ACE_Dev_Poll_Reactor::alertable_handle_events (  ACE_Time_Value &    max_wait_time )  [virtual]

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::alertable_handle_events (  ACE_Time_Value *    max_wait_time = 0 )  [virtual]

Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::cancel_timer (  long    timer_id, const void **    arg = 0, int    dont_call_handle_close = 1 )  [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.

int ACE_Dev_Poll_Reactor::cancel_timer (  ACE_Event_Handler *    event_handler, int    dont_call_handle_close = 1 )  [virtual]

Cancel all Event_Handlers that match the address of <event_handler>. Returns number of handlers cancelled. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::cancel_wakeup (  ACE_HANDLE    handle, ACE_Reactor_Mask    masks_to_be_cleared )  [virtual]

Clear <masks_to_be_cleared> from the <handle>'s entry. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::cancel_wakeup (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    masks_to_be_cleared )  [virtual]

Clear <masks_to_be_cleared> from the <event_handler>'s entry. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::close (  void    )  [virtual]

Close down and release all resources. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::current_info (  ACE_HANDLE   , size_t &    )  [virtual]

Returns 0, if the size of the current message has been put in size. Returns -1, if not. ACE_HANDLE allows the reactor to check if the caller is valid. Implements ACE_Reactor_Impl.

void ACE_Dev_Poll_Reactor::deactivate (  int    do_stop )  [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.

int ACE_Dev_Poll_Reactor::deactivated (  void    )  [virtual]

Return the status of Reactor. If this function returns 0, the reactor is actively handling events. If it returns non-zero, handle_events() and handle_alertable_events() return -1 immediately. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::dispatch (  void    )  [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.

int ACE_Dev_Poll_Reactor::dispatch_io_events (  int &    io_handlers_dispatched )  [protected]

Dispatch all IO related events to their corresponding event handlers.

int ACE_Dev_Poll_Reactor::dispatch_timer_handlers (  int &    number_of_handlers_dispatched )  [protected]

void ACE_Dev_Poll_Reactor::dump (  void    )  const [virtual]

Dump the state of an object. Implements ACE_Reactor_Impl.

ACE_Event_Handler * ACE_Dev_Poll_Reactor::find_handler (  ACE_HANDLE    handle )  [virtual]

Return the Event_Handler associated with <handle>. Return 0 if <handle> is not registered. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::handle_events (  ACE_Time_Value &    max_wait_time )  [virtual]

This method is just like the one above, except the max_wait_time value is a reference and can therefore never be NULL. Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::handle_events (  ACE_Time_Value *    max_wait_time = 0 )  [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. 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 ACE_Event_Handlers that were dispatched, 0 if the max_wait_time elapsed without dispatching any handlers, or -1 if an error occurs. The only difference between 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. Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::handle_events_i (  ACE_Time_Value *    max_wait_time )  [protected]

This is a helper method called by all handle_events() methods.

int ACE_Dev_Poll_Reactor::handler (  int    signum, ACE_Event_Handler **    = 0 )  [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.

int ACE_Dev_Poll_Reactor::handler (  ACE_HANDLE    handle, ACE_Reactor_Mask    mask, ACE_Event_Handler **    event_handler = 0 )  [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.

int ACE_Dev_Poll_Reactor::initialized (  void    )  [virtual]

Returns true if Reactor has been successfully initialized, else false. Implements ACE_Reactor_Impl.

ACE_Lock & ACE_Dev_Poll_Reactor::lock (  void    )  [virtual]

Returns a reference to the Reactor's internal lock. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::mask_ops (  ACE_HANDLE    handle, ACE_Reactor_Mask    mask, int    ops )  [virtual]

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::mask_ops (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask, int    ops )  [virtual]

GET/SET/ADD/CLR the dispatch mask "bit" bound with the event_handler and mask. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::mask_ops_i (  ACE_HANDLE    handle, ACE_Reactor_Mask    mask, int    ops )  [protected]

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask. This internal helper method acquires no lock.

int ACE_Dev_Poll_Reactor::max_notify_iterations (  void    )  [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.

void ACE_Dev_Poll_Reactor::max_notify_iterations (  int    )  [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.

int ACE_Dev_Poll_Reactor::notify (  ACE_Event_Handler *    event_handler = 0, ACE_Reactor_Mask    mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *    = 0 )  [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.

int ACE_Dev_Poll_Reactor::open (  size_t    size, int    restart = 0, ACE_Sig_Handler *    = 0, ACE_Timer_Queue *    = 0, int    disable_notify_pipe = 0, ACE_Reactor_Notify *    = 0 )  [virtual]

Initialization. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::owner (  ACE_thread_t *    owner )  [virtual]

Return the ID of the "owner" thread. Note: There is no need to set the owner of the event loop for the ACE_Dev_Poll_Reactor. Multiple threads may invoke the event loop simulataneously. As such, this method is a no-op. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::owner (  ACE_thread_t    new_owner, ACE_thread_t *    old_owner = 0 )  [virtual]

Transfers ownership of Reactor_Impl to the new_owner. Note: There is no need to set the owner of the event loop for the ACE_Dev_Poll_Reactor. Multiple threads may invoke the event loop simulataneously. As such, this method is a no-op. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::purge_pending_notifications (  ACE_Event_Handler *    = 0, ACE_Reactor_Mask    = ACE_Event_Handler::ALL_EVENTS_MASK )  [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.

short ACE_Dev_Poll_Reactor::reactor_mask_to_poll_event (  ACE_Reactor_Mask    mask )  [protected]

Convert a reactor mask to its corresponding poll() event mask.

int ACE_Dev_Poll_Reactor::ready_ops (  ACE_HANDLE    handle, ACE_Reactor_Mask   , int    ops )  [virtual]

GET/SET/ADD/CLR the ready "bit" bound with the handle and mask. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::ready_ops (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask, int    ops )  [virtual]

GET/SET/ADD/CLR the ready "bit" bound with the event_handler and mask. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::register_handler (  const ACE_Sig_Set &    sigset, ACE_Event_Handler *    new_sh, ACE_Sig_Action *    new_disp = 0 )  [virtual]

Registers <new_sh> to handle a set of signals <sigset> using the <new_disp>. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::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]

Register <new_sh> to handle the signal <signum> using the <new_disp>. Returns the <old_sh> that was previously registered (if any), along with the <old_disp> of the signal handler. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::register_handler (  const ACE_Handle_Set &    handles, ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask )  [virtual]

Register <event_handler> with all the <handles> in the <Handle_Set>. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::register_handler (  ACE_HANDLE    event_handle, ACE_HANDLE    io_handle, ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask )  [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.

int ACE_Dev_Poll_Reactor::register_handler (  ACE_HANDLE    io_handle, ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask )  [virtual]

Register event_handler with mask. The I/O handle is provided through the io_handle parameter. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::register_handler (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask )  [virtual]

Register event_handler with mask. The I/O handle will always come from get_handle on the event_handler. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::register_handler_i (  ACE_HANDLE    handle, ACE_Event_Handler *    eh, ACE_Reactor_Mask    mask )  [protected]

Register the given event handler with the reactor.

int ACE_Dev_Poll_Reactor::remove_handler (  const ACE_Sig_Set &    sigset )  [virtual]

Calls <remove_handler> for every signal in <sigset>. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::remove_handler (  int    signum, ACE_Sig_Action *    new_disp, ACE_Sig_Action *    old_disp = 0, int    sigkey = -1 )  [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.

int ACE_Dev_Poll_Reactor::remove_handler (  const ACE_Handle_Set &    handle_set, ACE_Reactor_Mask    mask )  [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.

int ACE_Dev_Poll_Reactor::remove_handler (  ACE_HANDLE    handle, ACE_Reactor_Mask    mask )  [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.

int ACE_Dev_Poll_Reactor::remove_handler (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    mask )  [virtual]

Removes <event_handler>. Note that the I/O handle will be obtained using <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.

int ACE_Dev_Poll_Reactor::remove_handler_i (  ACE_HANDLE    handle, ACE_Reactor_Mask    mask )  [protected]

Remove the event handler associated with the given handle and event mask from the "interest set."

int ACE_Dev_Poll_Reactor::requeue_position (  void    )  [virtual]

Get position of the owner thread. Note: This is currently a no-op. Implements ACE_Reactor_Impl.

void ACE_Dev_Poll_Reactor::requeue_position (  int    )  [virtual]

Set position of the owner thread. Note: This is currently a no-op. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::reset_timer_interval (  long    timer_id, const ACE_Time_Value &    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.

int ACE_Dev_Poll_Reactor::restart (  int    r )  [virtual]

Set a new value for restart and return the original value. Parameters: r  If zero, then the event loop will not be automatically restarted if the underlying poll is interrupted via the INTR (interrupt) signal. Returns: Returns the previous "restart" value. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::restart (  void    )  [virtual]

Get the existing restart value. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::resumable_handler (  void    )  [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.

int ACE_Dev_Poll_Reactor::resume_handler (  const ACE_Handle_Set &    handles )  [virtual]

Resume all handles in handle set. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::resume_handler (  ACE_HANDLE    handle )  [virtual]

Resume handle. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::resume_handler (  ACE_Event_Handler *    event_handler )  [virtual]

Resume event_handler. Use ACE_Event_Handler::get_handle() to get the handle. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::resume_handler_i (  ACE_HANDLE    handle )  [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.

int ACE_Dev_Poll_Reactor::resume_handlers (  void    )  [virtual]

Resume all handles. Implements ACE_Reactor_Impl.

long ACE_Dev_Poll_Reactor::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]

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.

int ACE_Dev_Poll_Reactor::schedule_wakeup (  ACE_HANDLE    handle, ACE_Reactor_Mask    masks_to_be_added )  [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.

int ACE_Dev_Poll_Reactor::schedule_wakeup (  ACE_Event_Handler *    event_handler, ACE_Reactor_Mask    masks_to_be_added )  [virtual]

Add <masks_to_be_added> to the <event_handler>'s entry. <event_handler> must already have been registered. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::set_sig_handler (  ACE_Sig_Handler *    signal_handler )  [virtual]

Use a user specified signal handler instead. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::set_timer_queue (  ACE_Timer_Queue *    tq )  [virtual]

Set a user specified timer queue. Note: This method is deprecated. See also: timer_queue Implements ACE_Reactor_Impl.

size_t ACE_Dev_Poll_Reactor::size (  void    )  const [virtual]

Returns the current size of the Reactor's internal descriptor table. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler (  const ACE_Handle_Set &    handles )  [virtual]

Suspend all handles in handle set temporarily. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler (  ACE_HANDLE    handle )  [virtual]

Suspend handle temporarily. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler (  ACE_Event_Handler *    event_handler )  [virtual]

Suspend event_handler temporarily. Use ACE_Event_Handler::get_handle() to get the handle. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::suspend_handler_i (  ACE_HANDLE    handle )  [protected]

Temporarily remove the given handle from the "interest set.".

int ACE_Dev_Poll_Reactor::suspend_handlers (  void    )  [virtual]

Suspend all handles temporarily. Implements ACE_Reactor_Impl.

ACE_Timer_Queue * ACE_Dev_Poll_Reactor::timer_queue (  void    )  const [virtual]

Return the current ACE_Timer_Queue. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::timer_queue (  ACE_Timer_Queue *    tq )  [virtual]

Set a user-specified timer queue. Implements ACE_Reactor_Impl.

ACE_INLINE int ACE_Dev_Poll_Reactor::upcall (  ACE_Event_Handler *    event_handler, int(ACE_Event_Handler::*    callback)(ACE_HANDLE), ACE_HANDLE    handle )  [protected]

Perform the upcall with the given event handler method. Todo: Resume the handler so that other threads will be allowed to dispatch the handler.

int ACE_Dev_Poll_Reactor::uses_event_associations (  void    )  [virtual]

Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. Implements ACE_Reactor_Impl.

void ACE_Dev_Poll_Reactor::wakeup_all_threads (  void    )  [virtual]

Wake up all threads waiting in the event loop. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::work_pending (  const ACE_Time_Value &    max_wait_time = ACE_Time_Value::zero )  [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". Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor. Implements ACE_Reactor_Impl.

int ACE_Dev_Poll_Reactor::work_pending_i (  ACE_Time_Value *    max_wait_time )  [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". Note: It is only possible to achieve millisecond timeout resolutions with the ACE_Dev_Poll_Reactor.

---

Member Data Documentation

ACE_Dev_Poll_Reactor::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Reimplemented from ACE_Reactor_Impl.

sig_atomic_t ACE_Dev_Poll_Reactor::deactivated_ [protected]

This flag is used to keep track of whether we are actively handling events or not.

int ACE_Dev_Poll_Reactor::delete_notify_handler_ [protected]

Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it).

int ACE_Dev_Poll_Reactor::delete_signal_handler_ [protected]

Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).

int ACE_Dev_Poll_Reactor::delete_timer_queue_ [protected]

Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).

struct pollfd* ACE_Dev_Poll_Reactor::end_pfds_ [protected]

The last element in the pollfd array plus one. The loop that dispatches IO events stops when this->start_pfds == this->end_pfds_.

ACE_Dev_Poll_Reactor_Handler_Repository ACE_Dev_Poll_Reactor::handler_rep_ [protected]

The repository that contains all registered event handlers.

char ACE_Dev_Poll_Reactor::initialized_ [protected]

Has the reactor been initialized.

ACE_SYNCH_MUTEX ACE_Dev_Poll_Reactor::lock_ [protected]

Lock used for synchronization of reactor state.

ACE_Lock_Adapter<ACE_SYNCH_MUTEX> ACE_Dev_Poll_Reactor::lock_adapter_ [protected]

Adapter used to return internal lock to outside world.

int ACE_Dev_Poll_Reactor::mask_signals_ [protected]

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.

char* ACE_Dev_Poll_Reactor::mmap_ [protected]

The memory map that `/dev/epoll' will feed its results to. Track HANDLES we are interested in for various events that must be dispatched *without* polling. ACE_Dev_Poll_Ready_Set ready_set_;

ACE_Reactor_Notify* ACE_Dev_Poll_Reactor::notify_handler_ [protected]

Callback object that unblocks the <ACE_Select_Reactor> if it's sleeping.

ACE_HANDLE ACE_Dev_Poll_Reactor::poll_fd_ [protected]

All interactions with the `/dev/poll' or `/dev/epoll' device are done through this file descriptor.

int ACE_Dev_Poll_Reactor::restart_ [protected]

Restart the handle_events event loop method automatically when polling function in use (ioctl() in this case) is interrupted via an EINTR signal.

ACE_Sig_Handler* ACE_Dev_Poll_Reactor::signal_handler_ [protected]

Handle signals without requiring global/static variables.

size_t ACE_Dev_Poll_Reactor::size_ [protected]

The maximum number of file descriptors over which demultiplexing will occur.

struct pollfd* ACE_Dev_Poll_Reactor::start_pfds_ [protected]

Pointer to the next pollfd array element that contains the next event to be dispatched.

ACE_Timer_Queue* ACE_Dev_Poll_Reactor::timer_queue_ [protected]

Defined as a pointer to allow overriding by derived classes...

---

The documentation for this class was generated from the following files:

• Dev_Poll_Reactor.h
• Dev_Poll_Reactor.cpp
• Dev_Poll_Reactor.inl

---