ACE  6.3.3
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
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]

Public Member Functions

 ACE_Select_Reactor_T (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO)
 
 ACE_Select_Reactor_T (size_t size, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO)
 
virtual int open (size_t max_number_of_handles=DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *=0)
 
virtual int current_info (ACE_HANDLE, size_t &size)
 Returns -1 (not used in this implementation);. More...
 
virtual int set_sig_handler (ACE_Sig_Handler *signal_handler)
 Use a user specified signal handler instead. More...
 
virtual int timer_queue (ACE_Timer_Queue *tq)
 Set a user-specified timer queue. More...
 
virtual ACE_Timer_Queuetimer_queue (void) const
 Return the current ACE_Timer_Queue. More...
 
virtual int close (void)
 Close down the select_reactor and release all of its resources. More...
 
virtual ~ACE_Select_Reactor_T (void)
 Close down the select_reactor and release all of its resources. More...
 
virtual int work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
 
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. More...
 
virtual int register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 Not implemented. More...
 
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>. More...
 
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. More...
 
virtual int suspend_handler (ACE_Event_Handler *eh)
 Temporarily suspend the <Event_Handler> associated with eh. More...
 
virtual int suspend_handler (ACE_HANDLE handle)
 Temporarily suspend the Event_Handler associated with handle. More...
 
virtual int suspend_handler (const ACE_Handle_Set &handles)
 Suspend all handles in handle set temporarily. More...
 
virtual int suspend_handlers (void)
 Suspend all the <Event_Handlers> in the Select_Reactor. More...
 
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. More...
 
virtual int resume_handlers (void)
 Resume all the <Event_Handlers> in the Select_Reactor. More...
 
virtual bool uses_event_associations (void)
 
virtual long schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval=ACE_Time_Value::zero)
 
virtual int reset_timer_interval (long timer_id, const ACE_Time_Value &interval)
 
virtual int cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1)
 
virtual int cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1)
 
virtual int schedule_wakeup (ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
 ADD the dispatch MASK "bit" bound with the eh and the mask. More...
 
virtual int schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask)
 ADD the dispatch MASK "bit" bound with the handle and the mask. More...
 
virtual int cancel_wakeup (ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
 CLR the dispatch MASK "bit" bound with the eh and the mask. More...
 
virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask)
 CLR the dispatch MASK "bit" bound with the handle and the mask. More...
 
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 bool restart (void)
 Get the existing restart value. More...
 
virtual bool restart (bool r)
 Set a new value for restart and return the original value. More...
 
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. More...
 
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. More...
 
virtual void wakeup_all_threads (void)
 Wake up all threads in waiting in the event loop. More...
 
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. More...
 
virtual int owner (ACE_thread_t *)
 Return the current owner of the thread. More...
 
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 bool initialized (void)
 Returns true if we've been successfully initialized, else false. More...
 
virtual size_t size (void) const
 
virtual ACE_Locklock (void)
 
virtual void dump (void) const
 Dump the state of an object. More...
 
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)
 
- Public Member Functions inherited from ACE_Select_Reactor_Impl
 ACE_Select_Reactor_Impl (bool mask_signals=true)
 Constructor. More...
 
virtual int purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
 
virtual int resumable_handler (void)
 
- Public Member Functions inherited from ACE_Reactor_Impl
virtual ~ACE_Reactor_Impl (void)
 Close down and release all resources. More...
 

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...
 
- Public Attributes inherited from ACE_Reactor_Impl
 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...
 

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. More...
 
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. More...
 
virtual int suspend_i (ACE_HANDLE handle)
 Suspend the <Event_Handler> associated with handle. More...
 
virtual int is_suspended_i (ACE_HANDLE handle)
 
virtual int resume_i (ACE_HANDLE handle)
 Resume the <Event_Handler> associated with handle. More...
 
virtual ACE_Event_Handlerfind_handler_i (ACE_HANDLE handle)
 Implement the public handler method. More...
 
virtual int handler_i (ACE_HANDLE handle, ACE_Reactor_Mask, ACE_Event_Handler **=0)
 Implement the public handler method. More...
 
virtual int handler_i (int signum, ACE_Event_Handler **=0)
 Implement the public handler method. More...
 
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. More...
 
virtual int check_handles (void)
 Make sure the handles are all valid. More...
 
virtual int wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &, ACE_Time_Value *)
 Wait for events to occur. More...
 
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. More...
 
int handle_events_i (ACE_Time_Value *max_wait_time=0)
 Stops the VC++ compiler from bitching about exceptions and destructors. More...
 
- Protected Member Functions inherited from ACE_Select_Reactor_Impl
virtual int bit_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Select_Reactor_Handle_Set &handle_set, int ops)
 Allow manipulation of the <wait_set_> mask and <ready_set_> mask. More...
 
virtual void clear_dispatch_mask (ACE_HANDLE handle, ACE_Reactor_Mask mask)
 
int supress_notify_renew (void)
 
void supress_notify_renew (int sr)
 

Protected Attributes

ACE_SELECT_REACTOR_TOKEN token_
 Synchronization token for the MT_SAFE ACE_Select_Reactor. More...
 
ACE_Lock_Adapter< ACE_SELECT_REACTOR_TOKEN > lock_adapter_
 Adapter used to return internal lock to outside world. More...
 
sig_atomic_t deactivated_
 
- Protected Attributes inherited from ACE_Select_Reactor_Impl
ACE_Select_Reactor_Handler_Repository handler_rep_
 Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s. More...
 
ACE_Select_Reactor_Handle_Set dispatch_set_
 Tracks handles that are ready for dispatch from <select> More...
 
ACE_Select_Reactor_Handle_Set wait_set_
 Tracks handles that are waited for by <select>. More...
 
ACE_Select_Reactor_Handle_Set suspend_set_
 Tracks handles that are currently suspended. More...
 
ACE_Select_Reactor_Handle_Set ready_set_
 
ACE_Timer_Queuetimer_queue_
 Defined as a pointer to allow overriding by derived classes... More...
 
ACE_Sig_Handlersignal_handler_
 Handle signals without requiring global/static variables. More...
 
ACE_Reactor_Notifynotify_handler_
 
bool delete_timer_queue_
 
bool delete_signal_handler_
 
bool delete_notify_handler_
 
bool initialized_
 True if we've been initialized yet... More...
 
bool restart_
 
int requeue_position_
 
ACE_thread_t owner_
 The original thread that created this Select_Reactor. More...
 
bool state_changed_
 
bool mask_signals_
 

Private Member Functions

 ACE_Select_Reactor_T (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)
 Deny access since member-wise won't work... More...
 
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > & operator= (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)
 

Additional Inherited Members

- Public Types inherited from ACE_Select_Reactor_Impl
enum  { DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE }
 

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_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 sh = 0,
ACE_Timer_Queue tq = 0,
int  disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
ACE_Reactor_Notify notify = 0,
bool  mask_signals = true,
int  s_queue = ACE_SELECT_TOKEN::FIFO 
)

If disable_notify_pipe is non-0 then the reactor will not create a notification pipe, which will save two I/O handles but will elide the notify() feature. If mask_signals is true the reactor is "signal-safe" when dispatching handlers to signal events, whereas if mask_signals is false the reactor will be more efficient, but not signal-safe (which may be perfectly fine if your application doesn't use the reactor to handle signals).

template<class ACE_SELECT_REACTOR_TOKEN >
ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T ( size_t  size,
bool  restart = false,
ACE_Sig_Handler sh = 0,
ACE_Timer_Queue tq = 0,
int  disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
ACE_Reactor_Notify notify = 0,
bool  mask_signals = true,
int  s_queue = ACE_SELECT_TOKEN::FIFO 
)

Initialize ACE_Select_Reactor with size

  • size. If
  • disable_notify_pipe is non-0 then the reactor will not create a notification pipe, which will save two I/O handles but will elide the notification feature. If
  • mask_signals is true the reactor is "signal-safe" when dispatching handlers to signal events, whereas if
  • mask_signals is false the reactor will be more efficient, but not signal-safe (which may be perfectly fine if your application doesn't use the reactor to handle signals).
    Note
    On Unix platforms, the size parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons.
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 = 0)
inlinevirtual

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.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events ( ACE_Time_Value max_wait_time)
inlinevirtual

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.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready ( ACE_Select_Reactor_Handle_Set handle_set)
protectedvirtual

Check if there are any HANDLEs enabled in the <ready_set_>, and if so, update the handle_set and return the number ready. If there aren't any HANDLEs enabled return 0.

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

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

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.

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.

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

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 >::cancel_wakeup ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask 
)
inlinevirtual

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 >::check_handles ( void  )
protectedvirtual

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 &  size 
)
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)
inlinevirtual

Control whether the Reactor will handle any more incoming events or not. If do_stop == 1, the Reactor will be disabled. By default, a reactor is in active state and can be deactivated/reactived as wish.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated ( void  )
inlinevirtual

Return the status of Reactor. If this function returns 0, the reactor is actively handling events. If it returns non-zero, <handling_events> and <handle_alertable_events> return -1 immediately.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch ( int  nfound,
ACE_Select_Reactor_Handle_Set dispatch_set 
)
protectedvirtual

Template Method that dispatches ACE_Event_Handlers for time events, I/O events, and signal events. Returns the total number of ACE_Event_Handlers that were dispatched or -1 if something goes wrong.

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

Dispatch all the input/output/except handlers that are enabled in the dispatch_set. Updates number_of_active_handles and number_of_handlers_dispatched according to the behavior of the number Returns -1 if the state of the <wait_set_> has changed, else 0.

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

Factors the dispatching of an io handle set (each WRITE, EXCEPT or READ set of handles). It updates the number_of_handlers_dispatched and invokes this->notify_handle for all the handles in <dispatch_set> using the mask, <ready_set> and callback parameters. Must return -1 if this->state_changed otherwise it must return 0.

Reimplemented in ACE_Priority_Reactor.

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

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

Dispatch all timer handlers that have expired. Returns -1 if the state of the <wait_set_> has changed, else 0. <number_dispatched> is set to the number of timer handlers dispatched.

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

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_error ( void  )
protectedvirtual

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 = 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 ( 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_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 ( 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 ( int  signum,
ACE_Event_Handler **  handler = 0 
)
inlinevirtual

Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the eh associated with this handler if eh != 0.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Event_Handler **  eh = 0 
)
protectedvirtual

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i ( int  signum,
ACE_Event_Handler **  eh = 0 
)
protectedvirtual

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >
bool 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)
protectedvirtual

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

Implements ACE_Select_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >
ACE_Lock & ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock ( void  )
inlinevirtual

Returns a reference to the ACE_Reactor_Token that is used to serialize the internal processing logic. This can be useful for situations where you need to avoid deadlock efficiently when ACE_Event_Handlers are used in multiple threads.

Implements ACE_Reactor_Impl.

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

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 >::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 >
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations ( int  iterations)
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 >::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 >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify ( ACE_Event_Handler eh = 0,
ACE_Reactor_Mask  mask = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value timeout = 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 ready_mask,
ACE_Event_Handler eh,
ACE_EH_PTMF  callback 
)
protectedvirtual

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

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::open ( size_t  max_number_of_handles = DEFAULT_SIZE,
bool  restart = false,
ACE_Sig_Handler sh = 0,
ACE_Timer_Queue tq = 0,
int  disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
ACE_Reactor_Notify notify = 0 
)
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  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 >::owner ( ACE_thread_t t_id)
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 >::ready_ops ( ACE_Event_Handler eh,
ACE_Reactor_Mask  mask,
int  ops 
)
inlinevirtual

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 >::ready_ops ( ACE_HANDLE  handle,
ACE_Reactor_Mask  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 >::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.

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.

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

Not implemented.

Implements ACE_Reactor_Impl.

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

Not implemented.

Implements ACE_Reactor_Impl.

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.

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

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

Implements ACE_Reactor_Impl.

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.

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

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

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

Register a set of handles.

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 ( 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 ( ACE_HANDLE  handle,
ACE_Reactor_Mask  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 ( const ACE_Handle_Set handle_set,
ACE_Reactor_Mask  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 ( int  signum,
ACE_Sig_Action new_disp,
ACE_Sig_Action old_disp = 0,
int  sigkey = -1 
)
inlinevirtual

Remove the ACE_Event_Handler currently associated with signum. sigkey is ignored in this implementation since there is only one instance of a signal handler. Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if signum is invalid.

Implements ACE_Reactor_Impl.

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_i ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask 
)
protectedvirtual

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

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  mask 
)
protectedvirtual

Remove a set of handles.

template<class ACE_SELECT_REACTOR_TOKEN >
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::renew ( void  )
protectedvirtual

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 >
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position ( int  rp)
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 >::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 >
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.

template<class ACE_SELECT_REACTOR_TOKEN >
bool 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 >
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart ( bool  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 >::resume_handler ( ACE_Event_Handler eh)
inlinevirtual

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_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 ( const ACE_Handle_Set handles)
inlinevirtual

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_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)
protectedvirtual

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_handlerEvent handler to schedule on reactor
argArgument passed to the handle_timeout() method of event_handler
delayTime interval after which the timer will expire
intervalTime interval after which the timer will be automatically rescheduled
Returns
-1 on failure, a timer_id value on success

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

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 >::schedule_wakeup ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask 
)
inlinevirtual

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 >::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
inlinevirtual

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 ( ACE_Event_Handler eh)
inlinevirtual

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_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 ( const ACE_Handle_Set handles)
inlinevirtual

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_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)
protectedvirtual

Suspend the <Event_Handler> associated with handle.

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 >
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 >
bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::uses_event_associations ( void  )
inlinevirtual

Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise. Since the Select_Reactor does not do any event associations, this function always return false.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >
int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wait_for_multiple_events ( ACE_Select_Reactor_Handle_Set dispatch_set,
ACE_Time_Value max_wait_time 
)
protectedvirtual

Wait for events to occur.

template<class ACE_SELECT_REACTOR_TOKEN >
void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wakeup_all_threads ( void  )
inlinevirtual

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.

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: