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

ACE_Reactor Class Reference

The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., or . More...

#include <Reactor.h>

Collaboration diagram for ACE_Reactor:

Collaboration graph
[legend]
List of all members.

Public Types

typedef int (* REACTOR_EVENT_HOOK )(void*)
enum  { GET_MASK = 1, SET_MASK = 2, ADD_MASK = 3, CLR_MASK = 4 }
 Operations on the "ready" mask and the "dispatch" mask. More...


Public Methods

virtual int run_reactor_event_loop (REACTOR_EVENT_HOOK = 0)
virtual int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK = 0)
virtual int run_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK = 0)
virtual int run_alertable_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK = 0)
virtual int end_reactor_event_loop (void)
virtual int reactor_event_loop_done (void)
 Indicate if the Reactor's event loop has been ended.

virtual void reset_reactor_event_loop (void)
 Resets the static so that the <run_event_loop> method can be restarted.

 ACE_Reactor (ACE_Reactor_Impl *implementation = 0, int delete_implementation = 0)
virtual ~ACE_Reactor (void)
 Close down and release all resources.

virtual int open (size_t max_number_of_handles, int restart = 0, ACE_Sig_Handler *signal_handler = 0, ACE_Timer_Queue *timer_queue = 0)
virtual int set_sig_handler (ACE_Sig_Handler *signal_handler)
 Use a user specified signal handler instead.

virtual int set_timer_queue (ACE_Timer_Queue *tq)
 Set a user specified timer queue.

virtual int timer_queue (ACE_Timer_Queue *tq)
 Set a user-specified timer queue. Return the current .

virtual ACE_Timer_Queuetimer_queue (void) const
virtual int close (void)
 Close down and release all resources.

virtual int work_pending (const ACE_Time_Value &max_wait_time = ACE_Time_Value::zero)
virtual int handle_events (ACE_Time_Value *max_wait_time = 0)
virtual int alertable_handle_events (ACE_Time_Value *max_wait_time = 0)
virtual int handle_events (ACE_Time_Value &max_wait_time)
virtual int alertable_handle_events (ACE_Time_Value &max_wait_time)
virtual int register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 Register <event_handler> with <mask>. The I/O handle will always come from <get_handle> on the <event_handler>.

virtual int register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 Register <event_handler> with <mask>. The I/O handle is provided through the <io_handle> parameter.

virtual int register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle = ACE_INVALID_HANDLE)
virtual int register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 Register <event_handler> with all the <handles> in the <Handle_Set>.

virtual int register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp = 0, ACE_Event_Handler **old_sh = 0, ACE_Sig_Action *old_disp = 0)
virtual int register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp = 0)
 Registers <new_sh> to handle a set of signals <sigset> using the <new_disp>.

virtual int remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask)
virtual int remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask mask)
virtual int remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp = 0, int sigkey = -1)
virtual int remove_handler (const ACE_Sig_Set &sigset)
 Calls <remove_handler> for every signal in <sigset>.

virtual int suspend_handler (ACE_Event_Handler *event_handler)
 Suspend <event_handler> temporarily. Use to get the handle.

virtual int suspend_handler (ACE_HANDLE handle)
 Suspend <handle> temporarily.

virtual int suspend_handler (const ACE_Handle_Set &handles)
 Suspend all <handles> in handle set temporarily.

virtual int suspend_handlers (void)
 Suspend all <handles> temporarily.

virtual int resume_handler (ACE_Event_Handler *event_handler)
 Resume <event_handler>. Use to get the handle.

virtual int resume_handler (ACE_HANDLE handle)
 Resume <handle>.

virtual int resume_handler (const ACE_Handle_Set &handles)
 Resume all <handles> in handle set.

virtual int resume_handlers (void)
 Resume all <handles>.

virtual int resumable_handler (void)
 Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. A positive value indicates that the handlers are application resumable. A value of 0 indicates otherwise.

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)
 Cancel all <Event_Handler>s that match the address of <event_handler>. Returns number of handlers cancelled.

virtual int cancel_timer (long timer_id, const void **arg = 0, int dont_call_handle_close = 1)
virtual int schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added)
 Add <masks_to_be_added> to the <event_handler>'s entry. <event_handler> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

virtual int schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added)
 Add <masks_to_be_added> to the <handle>'s entry. <event_handler> associated with <handle> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

virtual int cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared)
 Clear <masks_to_be_cleared> from the <event_handler>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared)
 Clear <masks_to_be_cleared> from the <handle>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

virtual int notify (ACE_Event_Handler *event_handler = 0, ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *tv = 0)
virtual void max_notify_iterations (int iterations)
virtual int max_notify_iterations (void)
virtual int purge_pending_notifications (ACE_Event_Handler *, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK)
virtual int handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler = 0)
virtual int handler (int signum, ACE_Event_Handler **event_handler = 0)
virtual int initialized (void)
 Returns true if Reactor has been successfully initialized, else false.

virtual size_t size (void) const
 Returns the current size of the Reactor's internal descriptor table.

virtual ACE_Locklock (void)
 Returns a reference to the Reactor's internal lock.

virtual void wakeup_all_threads (void)
 Wake up all threads in waiting in the event loop.

virtual int owner (ACE_thread_t new_owner, ACE_thread_t *old_owner = 0)
 Transfers ownership of Reactor to the <new_owner>.

virtual int owner (ACE_thread_t *owner)
 Return the ID of the "owner" thread.

virtual void requeue_position (int position)
 Set position of the owner thread.

virtual int requeue_position (void)
 Get position of the owner thread.

virtual int restart (void)
 Get the existing restart value.

virtual int restart (int r)
 Set a new value for restart and return the original value.

virtual int mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
 GET/SET/ADD/CLR the dispatch mask "bit" bound with the <event_handler> and <mask>.

virtual int mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
 GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle> and <mask>.

virtual int ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
 GET/SET/ADD/CLR the ready "bit" bound with the <event_handler> and <mask>.

virtual int ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
 GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.

virtual ACE_Reactor_Implimplementation (void) const
 Get the implementation class.

virtual int current_info (ACE_HANDLE handle, size_t &msg_size)
virtual int uses_event_associations (void)
 Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise.

void dump (void) const
 Dump the state of the object.


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.


Static Public Methods

ACE_Reactor* instance (void)
 Get pointer to a process-wide .

ACE_Reactor* instance (ACE_Reactor *, int delete_reactor = 0)
void close_singleton (void)
 Delete the dynamically allocated Singleton.

int run_event_loop (void)
int run_alertable_event_loop (void)
int run_event_loop (ACE_Time_Value &tv)
int run_alertable_event_loop (ACE_Time_Value &tv)
int end_event_loop (void)
int event_loop_done (void)
void reset_event_loop (void)
int check_reconfiguration (void *)

Protected Methods

virtual void implementation (ACE_Reactor_Impl *implementation)
 Set the implementation class.

 ACE_Reactor (const ACE_Reactor &)
 Deny access since member-wise won't work...

ACE_Reactor& operator= (const ACE_Reactor &)

Protected Attributes

ACE_Reactor_Implimplementation_
 Delegation/implementation class that all methods will be forwarded to.

int delete_implementation_
 Flag used to indicate whether we are responsible for cleaning up the implementation instance.


Static Protected Attributes

ACE_Reactor* reactor_ = 0
 Pointer to a process-wide singleton.

int delete_reactor_ = 0
 Must delete the <reactor_> singleton if non-0.


Detailed Description

The responsibility of this class is to forward all methods to its delegation/implementation class, e.g., or .


Member Typedef Documentation

typedef int(* ACE_Reactor::REACTOR_EVENT_HOOK)(void *)
 

You can add a hook to various run_event methods and the hook will be called after handling every reactor event. If this function returns 0, run_reactor_event_loop will check for the return value of handle_event. If it is -1, the the run_reactor_event_loop will return (pre-maturely.)


Member Enumeration Documentation

anonymous enum
 

Operations on the "ready" mask and the "dispatch" mask.

Enumeration values:
GET_MASK   Retrieve current value of the the "ready" mask or the "dispatch" mask.
SET_MASK   Set value of bits to new mask (changes the entire mask).
ADD_MASK   Bitwise "or" the value into the mask (only changes enabled bits).
CLR_MASK   Bitwise "and" the negation of the value out of the mask (only changes enabled bits).


Constructor & Destructor Documentation

ACE_Reactor::ACE_Reactor ( ACE_Reactor_Impl * implementation = 0,
int delete_implementation = 0 )
 

Create the Reactor using <implementation>. The flag <delete_implementation> tells the Reactor whether or not to delete the <implementation> on destruction.

ACE_Reactor::~ACE_Reactor ( void ) [virtual]
 

Close down and release all resources.

ACE_Reactor::ACE_Reactor ( const ACE_Reactor & ) [protected]
 

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


Member Function Documentation

ACE_INLINE int ACE_Reactor::alertable_handle_events ( ACE_Time_Value & max_wait_time ) [virtual]
 

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

ACE_INLINE int ACE_Reactor::cancel_timer ( long timer_id,
const void ** arg = 0,
int dont_call_handle_close = 1 ) [virtual]
 

Cancel the single <Event_Handler> that matches the <timer_id> value, which was returned from the schedule method. If arg is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the Event_Handler was registered. This makes it possible to free up the memory and avoid memory leaks. Returns 1 if cancellation succeeded and 0 if the <timer_id> wasn't found.

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

Cancel all <Event_Handler>s that match the address of <event_handler>. Returns number of handlers cancelled.

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

Clear <masks_to_be_cleared> from the <handle>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

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

Clear <masks_to_be_cleared> from the <event_handler>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

int ACE_Reactor::check_reconfiguration ( void * ) [static]
 

The singleton reactor is used by the . Therefore, we must check for the reconfiguration request and handle it after handling an event.

ACE_INLINE int ACE_Reactor::close ( void ) [virtual]
 

Close down and release all resources.

void ACE_Reactor::close_singleton ( void ) [static]
 

Delete the dynamically allocated Singleton.

ACE_INLINE int ACE_Reactor::current_info ( ACE_HANDLE handle,
size_t & size ) [virtual]
 

Returns 0, if the size of the current message has been put in <size> returns -1, if not. ACE_HANDLE allows the reactor to check if the caller is valid. Used for CLASSIX Reactor implementation.

void ACE_Reactor::dump ( void ) const
 

Dump the state of the object.

ACE_INLINE int ACE_Reactor::end_event_loop ( void ) [static]
 

Instruct the to terminate its event loop and notifies the so that it can wake up and close down gracefully. Note that this method can only be used by the singleton . Thus, to terminate another reactor, use .

int ACE_Reactor::end_reactor_event_loop ( void ) [virtual]
 

Instruct the Reactor to terminate its event loop and notifies the Reactor so that it can wake up and deactivate itself. Deactivating the Reactor would allow the Reactor to be shutdown gracefully. Internally the Reactor calls deactivate () on the underlying implementation.

ACE_INLINE int ACE_Reactor::event_loop_done ( void ) [static]
 

Report if the 's event loop is finished. Note that this method can only be used by the singleton . Thus, to check another reactor use .

ACE_INLINE int ACE_Reactor::handle_events ( ACE_Time_Value & max_wait_time ) [virtual]
 

This method is just like the one above, except the <max_wait_time> value is a reference and can therefore never be NULL.

The only difference between and <handle_events> is that in the alertable case, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

ACE_INLINE int ACE_Reactor::handle_events ( ACE_Time_Value * max_wait_time = 0 ) [virtual]
 

This event loop driver blocks for up to <max_wait_time> before returning. It will return earlier if events occur. Note that <max_wait_time> can be 0, in which case this method blocks indefinitely until events occur.

<max_wait_time> is decremented to reflect how much time this call took. For instance, if a time value of 3 seconds is passed to handle_events and an event occurs after 2 seconds, <max_wait_time> will equal 1 second. This can be used if an application wishes to handle events for some fixed amount of time.

Returns the total number of timers and I/O s that were dispatched, 0 if the <max_wait_time> elapsed without dispatching any handlers, or -1 if an error occurs.

The only difference between and <handle_events> is that in the alertable case, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

ACE_INLINE int ACE_Reactor::handler ( int signum,
ACE_Event_Handler ** event_handler = 0 ) [virtual]
 

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

ACE_INLINE int ACE_Reactor::handler ( ACE_HANDLE handle,
ACE_Reactor_Mask mask,
ACE_Event_Handler ** event_handler = 0 ) [virtual]
 

Check to see if <handle> is associated with a valid Event_Handler bound to <mask>. Return the <event_handler> associated with this <handler> if <event_handler> != 0.

ACE_INLINE void ACE_Reactor::implementation ( ACE_Reactor_Impl * impl ) [protected, virtual]
 

Set the implementation class.

ACE_INLINE ACE_Reactor_Impl * ACE_Reactor::implementation ( void ) const [virtual]
 

Get the implementation class.

ACE_INLINE int ACE_Reactor::initialized ( void ) [virtual]
 

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

ACE_Reactor * ACE_Reactor::instance ( ACE_Reactor * r,
int delete_reactor = 0 ) [static]
 

Set pointer to a process-wide and return existing pointer. If <delete_reactor> != 0 then we'll delete the Reactor at destruction time.

ACE_Reactor * ACE_Reactor::instance ( void ) [static]
 

Get pointer to a process-wide .

ACE_INLINE ACE_Lock & ACE_Reactor::lock ( void ) [virtual]
 

Returns a reference to the Reactor's internal lock.

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

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

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

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

ACE_INLINE int ACE_Reactor::max_notify_iterations ( void ) [virtual]
 

Get the maximum number of times that the ACE_Reactor will iterate and dispatch the that are passed in via the notify queue before breaking out of its loop.

ACE_INLINE void ACE_Reactor::max_notify_iterations ( int iterations ) [virtual]
 

Set the maximum number of times that ACE_Reactor will iterate and dispatch the that are passed in via the notify queue before breaking out of its loop. By default, this is set to -1, which means "iterate until the queue is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead.

ACE_INLINE int ACE_Reactor::notify ( ACE_Event_Handler * event_handler = 0,
ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value * tv = 0 ) [virtual]
 

Notify <event_handler> of <mask> event. The indicates how long to blocking trying to notify. If <timeout> == 0, the caller will block until action is possible, else will wait until the relative time specified in <timeout> elapses).

ACE_INLINE int ACE_Reactor::open ( size_t size,
int restart = 0,
ACE_Sig_Handler * signal_handler = 0,
ACE_Timer_Queue * timer_queue = 0 ) [virtual]
 

Initialize the to manage <max_number_of_handles>. If <restart> is non-0 then the '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.

ACE_Reactor& ACE_Reactor::operator= ( const ACE_Reactor & ) [protected]
 

ACE_INLINE int ACE_Reactor::owner ( ACE_thread_t * owner ) [virtual]
 

Return the ID of the "owner" thread.

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

Transfers ownership of Reactor to the <new_owner>.

ACE_INLINE int ACE_Reactor::purge_pending_notifications ( ACE_Event_Handler * eh,
ACE_Reactor_Mask mask = ACE_Event_Handler::ALL_EVENTS_MASK ) [virtual]
 

Purge any notifications pending in this reactor for the specified object. If <eh> == 0, all notifications for all handlers are removed (but not any notifications posted just to wake up the reactor itself). Returns the number of notifications purged. Returns -1 on error.

ACE_INLINE int ACE_Reactor::reactor_event_loop_done ( void ) [virtual]
 

Indicate if the Reactor's event loop has been ended.

ACE_INLINE int ACE_Reactor::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>.

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

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

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

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

ACE_INLINE int ACE_Reactor::register_handler ( int signum,
ACE_Event_Handler * new_sh,
ACE_Sig_Action * new_disp = 0,
ACE_Event_Handler ** old_sh = 0,
ACE_Sig_Action * old_disp = 0 ) [virtual]
 

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

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

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

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

Register an <event_handler> that will be notified when <event_handle> is signaled. <mask> specifies the network events that the <event_handler> is interested in.

ACE_INLINE int ACE_Reactor::register_handler ( ACE_Event_Handler * event_handler,
ACE_HANDLE event_handle = ACE_INVALID_HANDLE ) [virtual]
 

Register an <event_handler> that will be notified when <event_handle> is signaled. Since no event mask is passed through this interface, it is assumed that the <event_handle> being passed in is an event handle and not an I/O handle.

Originally this interface was available for all platforms, but because ACE_HANDLE is an int on non-Win32 platforms, compilers are not able to tell the difference between register_handler(ACE_Event_Handler*,ACE_Reactor_Mask) and register_handler(ACE_Event_Handler*,ACE_HANDLE). Therefore, we have restricted this method to Win32 only.

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

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

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

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

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

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

ACE_INLINE int ACE_Reactor::remove_handler ( int signum,
ACE_Sig_Action * new_disp,
ACE_Sig_Action * old_disp = 0,
int sigkey = -1 ) [virtual]
 

Remove the ACE_Event_Handler currently associated with <signum>. Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if <signum> is invalid.

ACE_INLINE int ACE_Reactor::remove_handler ( const ACE_Handle_Set & handle_set,
ACE_Reactor_Mask mask ) [virtual]
 

Removes all handles in <handle_set>. If <mask> == then the <handle_close> method of the associated <event_handler>s is not invoked.

ACE_INLINE int ACE_Reactor::remove_handler ( ACE_HANDLE handle,
ACE_Reactor_Mask mask ) [virtual]
 

Removes the associated with <handle>. If <mask> includes then the <handle_close> method of the associated <event_handler> is not invoked.

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

Removes <event_handler>. Note that the I/O handle will be obtained using <get_handle> method of <event_handler> . If <mask> includes then the <handle_close> method of the <event_handler> is not invoked.

ACE_INLINE int ACE_Reactor::requeue_position ( void ) [virtual]
 

Get position of the owner thread.

ACE_INLINE void ACE_Reactor::requeue_position ( int position ) [virtual]
 

Set position of the owner thread.

ACE_INLINE void ACE_Reactor::reset_event_loop ( void ) [static]
 

Resets the static so that the <run_event_loop> method can be restarted. Note that this method can only be used by the singleton . Thus, to reset another reactor use .

void ACE_Reactor::reset_reactor_event_loop ( void ) [virtual]
 

Resets the static so that the <run_event_loop> method can be restarted.

ACE_INLINE int ACE_Reactor::reset_timer_interval ( long timer_id,
const ACE_Time_Value & interval ) [virtual]
 

Resets the interval of the timer represented by <timer_id> to <interval>, which is specified in relative time to the current <gettimeofday>. If <interval> is equal to , the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not.

ACE_INLINE int ACE_Reactor::restart ( int r ) [virtual]
 

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

ACE_INLINE int ACE_Reactor::restart ( void ) [virtual]
 

Get the existing restart value.

int ACE_Reactor::resumable_handler ( void ) [virtual]
 

Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. A positive value indicates that the handlers are application resumable. A value of 0 indicates otherwise.

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

Resume all <handles> in handle set.

ACE_INLINE int ACE_Reactor::resume_handler ( ACE_HANDLE handle ) [virtual]
 

Resume <handle>.

ACE_INLINE int ACE_Reactor::resume_handler ( ACE_Event_Handler * event_handler ) [virtual]
 

Resume <event_handler>. Use to get the handle.

ACE_INLINE int ACE_Reactor::resume_handlers ( void ) [virtual]
 

Resume all <handles>.

ACE_INLINE int ACE_Reactor::run_alertable_event_loop ( ACE_Time_Value & tv ) [static]
 

ACE_INLINE int ACE_Reactor::run_alertable_event_loop ( void ) [static]
 

int ACE_Reactor::run_alertable_reactor_event_loop ( ACE_Time_Value & tv,
REACTOR_EVENT_HOOK eh = 0 ) [virtual]
 

int ACE_Reactor::run_alertable_reactor_event_loop ( REACTOR_EVENT_HOOK eh = 0 ) [virtual]
 

ACE_INLINE int ACE_Reactor::run_event_loop ( ACE_Time_Value & tv ) [static]
 

Run the event loop until the or methods returns -1, the <end_event_loop> method is invoked, or the expires. Note that this method can only be used by the singleton . Thus, to run another reactor use .

ACE_INLINE int ACE_Reactor::run_event_loop ( void ) [static]
 

Run the event loop until the method returns -1 or the <end_event_loop> method is invoked. Note that this method can only be used by the singleton . Thus, to run another reactor use .

int ACE_Reactor::run_reactor_event_loop ( ACE_Time_Value & tv,
REACTOR_EVENT_HOOK eh = 0 ) [virtual]
 

Run the event loop until the or methods returns -1, the <end_reactor_event_loop> method is invoked, or the expires.

int ACE_Reactor::run_reactor_event_loop ( REACTOR_EVENT_HOOK eh = 0 ) [virtual]
 

Run the event loop until the method returns -1 or the <end_reactor_event_loop> method is invoked.

ACE_INLINE long ACE_Reactor::schedule_timer ( ACE_Event_Handler * event_handler,
const void * arg,
const ACE_Time_Value & delta,
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

ACE_INLINE int ACE_Reactor::schedule_wakeup ( ACE_HANDLE handle,
ACE_Reactor_Mask masks_to_be_added ) [virtual]
 

Add <masks_to_be_added> to the <handle>'s entry. <event_handler> associated with <handle> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

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

Add <masks_to_be_added> to the <event_handler>'s entry. <event_handler> must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.

ACE_INLINE int ACE_Reactor::set_sig_handler ( ACE_Sig_Handler * signal_handler ) [virtual]
 

Use a user specified signal handler instead.

ACE_INLINE int ACE_Reactor::set_timer_queue ( ACE_Timer_Queue * tq ) [virtual]
 

Set a user specified timer queue.

ACE_INLINE size_t ACE_Reactor::size ( void ) const [virtual]
 

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

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

Suspend all <handles> in handle set temporarily.

ACE_INLINE int ACE_Reactor::suspend_handler ( ACE_HANDLE handle ) [virtual]
 

Suspend <handle> temporarily.

ACE_INLINE int ACE_Reactor::suspend_handler ( ACE_Event_Handler * event_handler ) [virtual]
 

Suspend <event_handler> temporarily. Use to get the handle.

ACE_INLINE int ACE_Reactor::suspend_handlers ( void ) [virtual]
 

Suspend all <handles> temporarily.

ACE_INLINE ACE_Timer_Queue * ACE_Reactor::timer_queue ( void ) const [virtual]
 

ACE_INLINE int ACE_Reactor::timer_queue ( ACE_Timer_Queue * tq ) [virtual]
 

Set a user-specified timer queue. Return the current .

ACE_INLINE int ACE_Reactor::uses_event_associations ( void ) [virtual]
 

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

ACE_INLINE void ACE_Reactor::wakeup_all_threads ( void ) [virtual]
 

Wake up all threads in waiting in the event loop.

ACE_INLINE int ACE_Reactor::work_pending ( const ACE_Time_Value & max_wait_time = ACE_Time_Value::zero ) [virtual]
 

Returns non-zero if there are I/O events "ready" for dispatching, but does not actually dispatch the event handlers. By default, don't block while checking this, i.e., "poll".


Member Data Documentation

ACE_Reactor::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

int ACE_Reactor::delete_implementation_ [protected]
 

Flag used to indicate whether we are responsible for cleaning up the implementation instance.

int ACE_Reactor::delete_reactor_ = 0 [static, protected]
 

Must delete the <reactor_> singleton if non-0.

ACE_Reactor_Impl * ACE_Reactor::implementation_ [protected]
 

Delegation/implementation class that all methods will be forwarded to.

ACE_Reactor * ACE_Reactor::reactor_ = 0 [static, protected]
 

Pointer to a process-wide singleton.


The documentation for this class was generated from the following files:
Generated at Sat Dec 1 11:04:35 2001 for ACE by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000