ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > Class Template Reference

An object oriented event demultiplexor and event handler dispatcher. More...

#include <Select_Reactor_T.h>

Inheritance diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:

Collaboration graph
[legend]
List of all members.

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_Queuetimer_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_Handlerfind_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_Locklock (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_Handlerfind_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 > &)

Detailed Description

template<class ACE_SELECT_REACTOR_TOKEN>
class ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >

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_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.


Constructor & Destructor Documentation

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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
 

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

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::~ACE_Select_Reactor_T void   )  [virtual]
 

Close down the select_reactor and release all of its resources.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &   )  [private]
 

Deny access since member-wise won't work...


Member Function Documentation

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events ACE_Time_Value max_wait_time  )  [virtual]
 

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events ACE_Time_Value max_wait_time = 0  )  [virtual]
 

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready ACE_Select_Reactor_Handle_Set handle_set  )  [protected, virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready_i ACE_Select_Reactor_Handle_Set handle_set  )  [protected, virtual]
 

Implement the <any_ready> method, assuming that the Sig_Guard is beign held

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer long  timer_id,
const void **  arg = 0,
int  dont_call_handle_close = 1
[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.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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>. 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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup ACE_HANDLE  handle,
ACE_Reactor_Mask  mask
[virtual]
 

CLR the dispatch MASK "bit" bound with the <handle> and the <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[virtual]
 

CLR the dispatch MASK "bit" bound with the <eh> and the <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::check_handles void   )  [protected, virtual]
 

Make sure the handles are all valid.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::close void   )  [virtual]
 

Close down the select_reactor and release all of its resources.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::current_info ACE_HANDLE  ,
size_t & 
[virtual]
 

Returns -1 (not used in this implementation);.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 wish.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated void   )  [virtual]
 

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<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch int  nfound,
ACE_Select_Reactor_Handle_Set
[protected, virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers ACE_Select_Reactor_Handle_Set dispatch_set,
int &  number_of_active_handles,
int &  number_of_handlers_dispatched
[protected, virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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
[protected, virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_notification_handlers ACE_Select_Reactor_Handle_Set dispatch_set,
int &  number_of_active_handles,
int &  number_of_handlers_dispatched
[protected, virtual]
 

Dispatch any notification handlers. Returns -1 if the state of the <wait_set_> has changed, else returns number of handlers notified.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_timer_handlers int &  number_dispatched  )  [protected, virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dump void   )  const [virtual]
 

Dump the state of an object.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Priority_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler ACE_HANDLE  handle  )  [virtual]
 

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler_i ACE_HANDLE  handle  )  [protected, virtual]
 

Implement the public <handler> method.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_error void   )  [protected, virtual]
 

Take corrective action when errors occur.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Current <alertable_handle_events> is identical to <handle_events>.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events ACE_Time_Value max_wait_time = 0  )  [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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events_i ACE_Time_Value max_wait_time = 0  )  [protected]
 

Stops the VC++ compiler from bitching about exceptions and destructors.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 <eh> associated with this <handler> if <eh> != 0.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Event_Handler **  eh = 0
[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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i int  signum,
ACE_Event_Handler **  = 0
[protected, virtual]
 

Implement the public <handler> method.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i ACE_HANDLE  handle,
ACE_Reactor_Mask  ,
ACE_Event_Handler **  = 0
[protected, virtual]
 

Implement the public <handler> method.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::initialized void   )  [virtual]
 

Returns true if we've been successfully initialized, else false.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::is_suspended_i ACE_HANDLE  handle  )  [protected, virtual]
 

Check to see if the <Event_Handler> associated with <handle> is suspended. Returns 0 if not, 1 if so.

Implements ACE_Select_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Lock & ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock void   )  [virtual]
 

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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::mask_ops ACE_Event_Handler eh,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the dispatch mask "bit" bound with the <eh> and <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations void   )  [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.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations int   )  [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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify ACE_Event_Handler = 0,
ACE_Reactor_Mask  = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value = 0
[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.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Handle_Set ,
ACE_Event_Handler eh,
ACE_EH_PTMF  callback
[protected, virtual]
 

Notify the appropriate <callback> in the context of the <eh> associated with <handle> that a particular event has occurred.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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]
 

Initialize the ACE_Select_Reactor to manage

  • max_number_of_handles. If
  • restart is non-0 then the ACE_Reactor's handle_events method will be restarted automatically when EINTR occurs. 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.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>& ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::operator= const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &   )  [private]
 

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner ACE_thread_t  )  [virtual]
 

Return the current owner of the thread.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner ACE_thread_t  n_id,
ACE_thread_t o_id = 0
[virtual]
 

Set the new owner of the thread and return the old owner.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ready_ops ACE_Event_Handler eh,
ACE_Reactor_Mask  mask,
int  ops
[virtual]
 

GET/SET/ADD/CLR the ready "bit" bound with the <eh> and <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler const ACE_Handle_Set handles,
ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[virtual]
 

Register <eh> with all the <handles> in the <Handle_Set>.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler ACE_HANDLE  event_handle,
ACE_HANDLE  io_handle,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask
[virtual]
 

Not implemented.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler ACE_Event_Handler event_handler,
ACE_HANDLE  event_handle = ACE_INVALID_HANDLE
[virtual]
 

Not implemented.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler ACE_HANDLE  handle,
ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[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.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[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.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i const ACE_Handle_Set handles,
ACE_Event_Handler handler,
ACE_Reactor_Mask  mask
[protected, virtual]
 

Register a set of <handles>.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i ACE_HANDLE  handle,
ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[protected, virtual]
 

Do the work of actually binding the <handle> and <eh> with the <mask>.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::release_token void   )  [protected]
 

Release the token lock when a Win32 structured exception occurs.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler const ACE_Sig_Set sigset  )  [virtual]
 

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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>. <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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler const ACE_Handle_Set handle_set,
ACE_Reactor_Mask 
[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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler ACE_HANDLE  handle,
ACE_Reactor_Mask 
[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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i const ACE_Handle_Set handles,
ACE_Reactor_Mask 
[protected, virtual]
 

Remove a set of <handles>.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i ACE_HANDLE  handle,
ACE_Reactor_Mask 
[protected, virtual]
 

Do the work of actually unbinding the <handle> and <eh> with the <mask>.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::renew void   )  [protected, virtual]
 

Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>.

Implements ACE_Select_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position void   )  [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.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position int   )  [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.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Reimplemented in ACE_FlReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart int  r  )  [virtual]
 

Set a new value for restart and return the original value.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart void   )  [virtual]
 

Get the existing restart value.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler const ACE_Handle_Set handles  )  [virtual]
 

Resume all <handles> in handle set.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler ACE_HANDLE  handle  )  [virtual]
 

Resume a temporarily suspended <Event_Handler> associated with <handle>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler ACE_Event_Handler eh  )  [virtual]
 

Resume a temporarily suspend <Event_Handler> associated with <eh>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handlers void   )  [virtual]
 

Resume all the <Event_Handlers> in the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_i ACE_HANDLE  handle  )  [protected, virtual]
 

Resume the <Event_Handler> associated with <handle>.

template<class ACE_SELECT_REACTOR_TOKEN>
long ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup ACE_HANDLE  handle,
ACE_Reactor_Mask  mask
[virtual]
 

ADD the dispatch MASK "bit" bound with the <handle> and the <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup ACE_Event_Handler eh,
ACE_Reactor_Mask  mask
[virtual]
 

ADD the dispatch MASK "bit" bound with the <eh> and the <mask>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::set_sig_handler ACE_Sig_Handler signal_handler  )  [virtual]
 

Use a user specified signal handler instead.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
size_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::size void   )  const [virtual]
 

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler const ACE_Handle_Set handles  )  [virtual]
 

Suspend all <handles> in handle set temporarily.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler ACE_HANDLE  handle  )  [virtual]
 

Temporarily suspend the <Event_Handler> associated with <handle>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler ACE_Event_Handler eh  )  [virtual]
 

Temporarily suspend the <Event_Handler> associated with <eh>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handlers void   )  [virtual]
 

Suspend all the <Event_Handlers> in the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_i ACE_HANDLE  handle  )  [protected, virtual]
 

Suspend the <Event_Handler> associated with <handle>.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Timer_Queue * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue void   )  const [virtual]
 

Return the current <ACE_Timer_Queue>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue ACE_Timer_Queue tq  )  [virtual]
 

Set a user-specified timer queue.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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. Since the Select_Reactor does not do any event associations, this function always return 0.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wait_for_multiple_events ACE_Select_Reactor_Handle_Set ,
ACE_Time_Value
[protected, virtual]
 

Wait for events to occur.

Reimplemented in ACE_FlReactor, ACE_QtReactor, ACE_TkReactor, and ACE_XtReactor.

template<class ACE_SELECT_REACTOR_TOKEN>
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wakeup_all_threads void   )  [virtual]
 

Wake up all threads in waiting in the event loop.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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".

Implements ACE_Reactor_Impl.


Member Data Documentation

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented from ACE_Reactor_Impl.

Reimplemented in ACE_Priority_Reactor, and ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>
sig_atomic_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated_ [protected]
 

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

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock_adapter_ [protected]
 

Adapter used to return internal lock to outside world.

template<class ACE_SELECT_REACTOR_TOKEN>
ACE_SELECT_REACTOR_TOKEN ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::token_ [protected]
 

Synchronization token for the MT_SAFE ACE_Select_Reactor.


The documentation for this class was generated from the following files:
Generated on Wed Nov 23 15:50:23 2005 for ACE by  doxygen 1.4.5