Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

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 Methods

 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 set_timer_queue (ACE_Timer_Queue *tq)
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 Methods

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_
int mask_signals_

Private Methods

 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>
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::set_timer_queue ACE_Timer_Queue   tq [virtual]
 

Deprecated:
The following method is deprecated. Use <timer_queue> instead. Set a user specified timer queue.

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

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 Fri Apr 2 16:53:13 2004 for ACE by doxygen1.2.18