ACE  6.2.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
ACE_Reactor Class Reference

This class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor. More...

#include <Reactor.h>

Inheritance diagram for ACE_Reactor:
Inheritance graph
[legend]
Collaboration diagram for ACE_Reactor:
Collaboration graph
[legend]

Public Types

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

Public Member Functions

int run_reactor_event_loop (REACTOR_EVENT_HOOK=0)
 
int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK=0)
 
int run_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK=0)
 
int run_alertable_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK=0)
 
int end_reactor_event_loop (void)
 
int reactor_event_loop_done (void)
 Indicate if the Reactor's event loop has been ended. More...
 
void reset_reactor_event_loop (void)
 
 ACE_Reactor (ACE_Reactor_Impl *implementation=0, bool delete_implementation=false)
 
virtual ~ACE_Reactor (void)
 Close down and release all resources. More...
 
int open (size_t max_number_of_handles, bool restart=false, ACE_Sig_Handler *signal_handler=0, ACE_Timer_Queue *timer_queue=0)
 
int set_sig_handler (ACE_Sig_Handler *signal_handler)
 Use a user specified signal handler instead. More...
 
int timer_queue (ACE_Timer_Queue *tq)
 Set a user-specified timer queue. More...
 
ACE_Timer_Queuetimer_queue (void) const
 Return the current ACE_Timer_Queue. More...
 
int close (void)
 Close down and release all resources. More...
 
int work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
 
int handle_events (ACE_Time_Value *max_wait_time=0)
 
int alertable_handle_events (ACE_Time_Value *max_wait_time=0)
 
int handle_events (ACE_Time_Value &max_wait_time)
 
int alertable_handle_events (ACE_Time_Value &max_wait_time)
 
int register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 
int register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 
int register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)
 
int register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
 
int register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks)
 
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)
 
int register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *event_handler, ACE_Sig_Action *sig_action=0)
 
int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask masks)
 
int remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks)
 
int remove_handler (const ACE_Handle_Set &handles, ACE_Reactor_Mask masks)
 
int remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=0, int sigkey=-1)
 
int remove_handler (const ACE_Sig_Set &sigset)
 
int suspend_handler (ACE_HANDLE handle)
 
int suspend_handler (ACE_Event_Handler *event_handler)
 
int suspend_handler (const ACE_Handle_Set &handles)
 
int suspend_handlers (void)
 
int resume_handler (ACE_HANDLE handle)
 
int resume_handler (ACE_Event_Handler *event_handler)
 
int resume_handler (const ACE_Handle_Set &handles)
 
int resume_handlers (void)
 
int resumable_handler (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 (long timer_id, const void **arg=0, int dont_call_handle_close=1)
 
virtual int cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1)
 
int schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added)
 
int schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added)
 
int cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared)
 
int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared)
 
int notify (ACE_Event_Handler *event_handler=0, ACE_Reactor_Mask masks=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *timeout=0)
 
void max_notify_iterations (int iterations)
 
int max_notify_iterations (void)
 
int purge_pending_notifications (ACE_Event_Handler *eh, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
 
ACE_Event_Handlerfind_handler (ACE_HANDLE handle)
 
int handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
 
int handler (int signum, ACE_Event_Handler **event_handler=0)
 
int initialized (void)
 
size_t size (void) const
 
ACE_Locklock (void)
 Returns a reference to the Reactor's internal lock. More...
 
void wakeup_all_threads (void)
 Wake up all threads in waiting in the event loop. More...
 
int owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0)
 Transfers ownership of Reactor to the new_owner. More...
 
int owner (ACE_thread_t *owner)
 Return the ID of the "owner" thread. More...
 
void requeue_position (int position)
 Set position of the owner thread. More...
 
int requeue_position (void)
 Get position of the owner thread. More...
 
bool restart (void)
 Get the existing restart value. More...
 
bool restart (bool r)
 Set a new value for restart and return the original value. More...
 
int mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
 
int mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
 
int ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
 
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. More...
 
ACE_Reactor_Implimplementation (void) const
 Get the implementation class. More...
 
int current_info (ACE_HANDLE handle, size_t &msg_size)
 
bool uses_event_associations (void)
 
void dump (void) const
 Dump the state of the object. More...
 
- Public Member Functions inherited from ACE_Reactor_Timer_Interface
virtual ~ACE_Reactor_Timer_Interface (void)
 

Static Public Member Functions

static ACE_Reactorinstance (void)
 Get pointer to a process-wide ACE_Reactor. More...
 
static ACE_Reactorinstance (ACE_Reactor *, bool delete_reactor=false)
 
static void close_singleton (void)
 Delete the dynamically allocated Singleton. More...
 
static const ACE_TCHARdll_name (void)
 Name of the dll in which the dll lives. More...
 
static const ACE_TCHARname (void)
 Name of the component–ACE_Reactor in this case. More...
 
static int run_event_loop (void)
 
static int run_alertable_event_loop (void)
 
static int run_event_loop (ACE_Time_Value &tv)
 
static int run_alertable_event_loop (ACE_Time_Value &tv)
 
static int end_event_loop (void)
 
static int event_loop_done (void)
 
static void reset_event_loop (void)
 
static int check_reconfiguration (ACE_Reactor *)
 

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...
 

Protected Member Functions

void implementation (ACE_Reactor_Impl *implementation)
 Set the implementation class. More...
 
 ACE_Reactor (const ACE_Reactor &)
 Deny access since member-wise won't work... More...
 
ACE_Reactoroperator= (const ACE_Reactor &)
 

Protected Attributes

ACE_Reactor_Implimplementation_
 
bool delete_implementation_
 

Static Protected Attributes

static ACE_Reactorreactor_ = 0
 Pointer to a process-wide ACE_Reactor singleton. More...
 
static bool delete_reactor_ = false
 Must delete the reactor_ singleton if true. More...
 

Detailed Description

This class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor.

Member Typedef Documentation

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

You can specify a hook function to event-handling methods that will be called after each iteration of event handling. If the hook function returns a non-zero value, the event loop will immediately resume waiting for the next event(s) to process without checking the error status of the just-completed iteration of event handling or the end-of-loop indication. If the hook function returns 0, the event handling error status and the end-of-loop indication will be checked as normal, just as if there is no hook function specified.

Member Enumeration Documentation

anonymous enum

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

Enumerator
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,
bool  delete_implementation = false 
)

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.

Any notifications that remain queued on this reactor instance are lost.

ACE_Reactor::ACE_Reactor ( const ACE_Reactor )
protected

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

Member Function Documentation

int ACE_Reactor::alertable_handle_events ( ACE_Time_Value max_wait_time = 0)
inline
int ACE_Reactor::alertable_handle_events ( ACE_Time_Value max_wait_time)
inline
int ACE_Reactor::cancel_timer ( long  timer_id,
const void **  arg = 0,
int  dont_call_handle_close = 1 
)
virtual

Cancel timer.

Cancel timer associated with timer_id that was returned from the schedule_timer() method. If arg is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the 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.

On successful cancellation, ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::TIMER_MASK. ACE_Event_Handler::remove_reference() will also be called.

Implements ACE_Reactor_Timer_Interface.

int ACE_Reactor::cancel_timer ( ACE_Event_Handler event_handler,
int  dont_call_handle_close = 1 
)
virtual

Cancel all timers associated with event handler.

Shorthand for calling cancel_timer(long,const void **,int) multiple times for all timer associated with event_handler.

ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::TIMER_MASK only once irrespective of the number of timers associated with the event handler. ACE_Event_Handler::remove_reference() will also be called once for every timer associated with the event handler.

Returns number of handlers cancelled.

Implements ACE_Reactor_Timer_Interface.

int ACE_Reactor::cancel_wakeup ( ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks_to_be_cleared 
)
inline

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

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.

int ACE_Reactor::check_reconfiguration ( ACE_Reactor )
static

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

int ACE_Reactor::close ( void  )
inline

Close down and release all resources.

void ACE_Reactor::close_singleton ( void  )
static

Delete the dynamically allocated Singleton.

int ACE_Reactor::current_info ( ACE_HANDLE  handle,
size_t &  msg_size 
)
inline

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.

const ACE_TCHAR * ACE_Reactor::dll_name ( void  )
static

Name of the dll in which the dll lives.

void ACE_Reactor::dump ( void  ) const
inline

Dump the state of the object.

int ACE_Reactor::end_event_loop ( void  )
inlinestatic

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

Deprecated:
Use ACE_Reactor::instance()->end_reactor_event_loop() instead
int ACE_Reactor::end_reactor_event_loop ( void  )
inline

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. Any queued notifications remain queued on return from this method. If the event loop is restarted in the future, the notifications will be dispatched then. If the reactor is closed or deleted without further dispatching, the notifications will be lost.

int ACE_Reactor::event_loop_done ( void  )
inlinestatic

Report if the ACE_Reactor::instance()'s event loop is finished. Note that this method can only be used by the singleton ACE_Reactor::instance(). Thus, to check another reactor use <ACE_Reactor::reactor_event_loop_done>.

Deprecated:
Use ACE_Reactor::instance()->reactor_event_loop_done() instead
ACE_Event_Handler * ACE_Reactor::find_handler ( ACE_HANDLE  handle)
inline

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

Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it.

int ACE_Reactor::handle_events ( ACE_Time_Value max_wait_time = 0)
inline

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 ACE_Event_Handlers that were dispatched, 0 if the max_wait_time elapsed without dispatching any handlers, or -1 if an error occurs.

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

int ACE_Reactor::handle_events ( ACE_Time_Value max_wait_time)
inline

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

int ACE_Reactor::handler ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
ACE_Event_Handler **  event_handler = 0 
)
inline

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.

Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it if event_handler != 0.

int ACE_Reactor::handler ( int  signum,
ACE_Event_Handler **  event_handler = 0 
)
inline

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_Reactor_Impl * ACE_Reactor::implementation ( void  ) const
inline

Get the implementation class.

void ACE_Reactor::implementation ( ACE_Reactor_Impl implementation)
inlineprotected

Set the implementation class.

int ACE_Reactor::initialized ( void  )
inline

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

ACE_Reactor * ACE_Reactor::instance ( void  )
static

Get pointer to a process-wide ACE_Reactor.

ACE_Reactor * ACE_Reactor::instance ( ACE_Reactor r,
bool  delete_reactor = false 
)
static

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

ACE_Lock & ACE_Reactor::lock ( void  )
inline

Returns a reference to the Reactor's internal lock.

int ACE_Reactor::mask_ops ( ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask,
int  ops 
)
inline

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

int ACE_Reactor::mask_ops ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
int  ops 
)
inline

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

void ACE_Reactor::max_notify_iterations ( int  iterations)
inline

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

int ACE_Reactor::max_notify_iterations ( void  )
inline

Get the maximum number of times that the ACE_Reactor will iterate and dispatch the ACE_Event_Handler's that are passed in via the notify queue before breaking out of its ACE_Message_Queue::dequeue() loop.

const ACE_TCHAR * ACE_Reactor::name ( void  )
static

Name of the component–ACE_Reactor in this case.

int ACE_Reactor::notify ( ACE_Event_Handler event_handler = 0,
ACE_Reactor_Mask  masks = ACE_Event_Handler::EXCEPT_MASK,
ACE_Time_Value timeout = 0 
)

Dispatch user specified events.

Handler will be dispatched irrespective of whether it is registered, not registered, or suspended in the Reactor.

If user specified event is successfully queued, ACE_Event_Handler::add_reference() will be called. After the notify occurs and the upcall to the handler completes, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called. No other upcall reference counting is done.

For I/O or OS events, the upcall is invoked with an ACE_INVALID_HANDLE.

For timer events, the upcall is invoked with a null ACT.

Parameters
event_handler,:IN - Handler on which the event will be dispatched.
masks,:IN - Events to be dispatched - multiple events can be OR'd together.
timeout,:INOUT - Relative time up to which to wait for user specified event to be queued. If tv is 0, wait indefinitely. When the call returns, tv has the time remaining after the call completes.
int ACE_Reactor::open ( size_t  max_number_of_handles,
bool  restart = false,
ACE_Sig_Handler signal_handler = 0,
ACE_Timer_Queue timer_queue = 0 
)
inline

Initialize the ACE_Reactor to manage max_number_of_handles. If restart is false 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.

ACE_Reactor& ACE_Reactor::operator= ( const ACE_Reactor )
protected
int ACE_Reactor::owner ( ACE_thread_t  new_owner,
ACE_thread_t old_owner = 0 
)
inline

Transfers ownership of Reactor to the new_owner.

int ACE_Reactor::owner ( ACE_thread_t owner)
inline

Return the ID of the "owner" thread.

int ACE_Reactor::purge_pending_notifications ( ACE_Event_Handler eh,
ACE_Reactor_Mask  mask = ACE_Event_Handler::ALL_EVENTS_MASK 
)
inline

Purge any notifications pending in this reactor for the specified ACE_Event_Handler 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.

After the purging occurs, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.

int ACE_Reactor::reactor_event_loop_done ( void  )
inline

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

int ACE_Reactor::ready_ops ( ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask,
int  ops 
)
inline

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

int ACE_Reactor::ready_ops ( ACE_HANDLE  handle,
ACE_Reactor_Mask  mask,
int  ops 
)
inline

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

int ACE_Reactor::register_handler ( ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask 
)

Register handler for I/O events.

A handler can be associated with multiple handles. A handle cannot be associated with multiple handlers.

The handle will come from ACE_Event_Handler::get_handle().

Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair.

If this handler/handle pair has already been registered, any new masks specified will be added. In this case, ACE_Event_Handler::add_reference() will not be called.

If the registered handler is currently suspended, it will remain suspended. When the handler is resumed, it will have the existing masks plus any masks added through this call. Handlers do not have partial suspensions.

int ACE_Reactor::register_handler ( ACE_HANDLE  io_handle,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask 
)

Register handler for I/O events.

Same as register_handler(ACE_Event_Handler*,ACE_Reactor_Mask), except handle is explicitly specified.

int ACE_Reactor::register_handler ( ACE_Event_Handler event_handler,
ACE_HANDLE  event_handle = ACE_INVALID_HANDLE 
)

Register handler for OS events.

Register an event_handler that will be notified when <event_handle> is signaled. This will call back its <handle_signal> hook method.

Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair.

This interface is only available Win32 platforms because ACE_HANDLE is an int on non-Win32 platforms and 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).

int ACE_Reactor::register_handler ( ACE_HANDLE  event_handle,
ACE_HANDLE  io_handle,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  mask 
)

Register handler for I/O events.

Similar to register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), except that the user gets to specify the event handle that will be used for this registration. This only applies to Reactors that use event handles for I/O registrations.

int ACE_Reactor::register_handler ( const ACE_Handle_Set handles,
ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks 
)

Register handler for multiple I/O events.

Shorthand for calling register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), multiple times for the same event_handler and masks but different handles.

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

Register handler for signals.

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.

Reactor will call ACE_Event_Handler::add_reference() on new_sh and ACE_Event_Handler::remove_reference() on old_sh.

int ACE_Reactor::register_handler ( const ACE_Sig_Set sigset,
ACE_Event_Handler event_handler,
ACE_Sig_Action sig_action = 0 
)
inline

Register handler for multiple signals.

Shorthand for calling register_handler(int,ACE_Event_Handler*,ACE_Sig_Action*,ACE_Event_Handler**,ACE_Sig_Action*) multiple times for the same event_handler and sig_action but different <signals>.

int ACE_Reactor::remove_handler ( ACE_HANDLE  handle,
ACE_Reactor_Mask  masks 
)
inline

Remove masks from handle registration.

For I/O handles, masks are removed from the Reactor. Unless masks includes ACE_Event_Handler::DONT_CALL, ACE_Event_Handler::handle_close() will be called with the masks that have been removed. If all masks have been removed, ACE_Event_Handler::remove_reference() will be called.

For OS handles, the handle is removed from the Reactor. Unless masks includes ACE_Event_Handler::DONT_CALL, ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::NULL_MASK. ACE_Event_Handler::remove_reference() will also be called.

int ACE_Reactor::remove_handler ( ACE_Event_Handler event_handler,
ACE_Reactor_Mask  masks 
)
inline

Remove masks from event_handler registration.

Same as remove_handler(ACE_HANDLE,ACE_Reactor_Mask), except handle comes from ACE_Event_Handler::get_handle().

int ACE_Reactor::remove_handler ( const ACE_Handle_Set handles,
ACE_Reactor_Mask  masks 
)
inline

Remove masks from multiple <handle> registrations.

Shorthand for calling remove_handler(ACE_HANDLE,ACE_Reactor_Mask) multiple times for the same masks but different handles.

int ACE_Reactor::remove_handler ( int  signum,
ACE_Sig_Action new_disp,
ACE_Sig_Action old_disp = 0,
int  sigkey = -1 
)
inline

Remove signal handler registration.

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

Note that the registered handler's ACE_Event_Handler::handle_close () callback will be called to indicate the signal handler has been removed. Unlike with I/O handles, there is no way to prevent this callback. The handle_close() callback can check the passed mask for the value ACE_Event_Handler::SIGNAL_MASK to tell when the callback is the result of a signal handler removal.

int ACE_Reactor::remove_handler ( const ACE_Sig_Set sigset)
inline

Remove multiple signal handler registrations.

Shorthand for calling remove_handler(int,ACE_Sig_Action*,ACE_Sig_Action*,int) multiple times for every signal in sigset.

void ACE_Reactor::requeue_position ( int  position)
inline

Set position of the owner thread.

int ACE_Reactor::requeue_position ( void  )
inline

Get position of the owner thread.

void ACE_Reactor::reset_event_loop ( void  )
inlinestatic

Resets the ACE_Reactor::end_event_loop_ static so that the run_event_loop() method can be restarted. Note that this method can only be used by the singleton ACE_Reactor::instance(). Thus, to reset another reactor use ACE_Reactor::reset_reactor_event_loop().

Deprecated:
Use ACE_Reactor::instance()->reset_reactor_event_loop() instead
void ACE_Reactor::reset_reactor_event_loop ( void  )
inline

Resets the ACE_Reactor::end_event_loop_ static so that the run_event_loop() method can be restarted.

int ACE_Reactor::reset_timer_interval ( long  timer_id,
const ACE_Time_Value interval 
)
virtual

Reset recurring timer interval.

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.

This change will not take effect until the next timeout.

Implements ACE_Reactor_Timer_Interface.

bool ACE_Reactor::restart ( void  )
inline

Get the existing restart value.

bool ACE_Reactor::restart ( bool  r)
inline

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

int ACE_Reactor::resumable_handler ( void  )
inline

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.

int ACE_Reactor::resume_handler ( ACE_HANDLE  handle)
inline

Resume handle.

int ACE_Reactor::resume_handler ( ACE_Event_Handler event_handler)
inline

Resume event_handler.

Handle is obtained from ACE_Event_Handler::get_handle().

int ACE_Reactor::resume_handler ( const ACE_Handle_Set handles)
inline

Resume handles.

Shorthand for calling resume_handler(ACE_HANDLE) with multiple handles.

int ACE_Reactor::resume_handlers ( void  )
inline

Resume all registered handles.

int ACE_Reactor::run_alertable_event_loop ( void  )
inlinestatic
int ACE_Reactor::run_alertable_event_loop ( ACE_Time_Value tv)
inlinestatic
int ACE_Reactor::run_alertable_reactor_event_loop ( REACTOR_EVENT_HOOK  eh = 0)
int ACE_Reactor::run_alertable_reactor_event_loop ( ACE_Time_Value tv,
REACTOR_EVENT_HOOK  eh = 0 
)
int ACE_Reactor::run_event_loop ( void  )
inlinestatic

Run the event loop until the ACE_Reactor::handle_events()/ACE_Reactor::alertable_handle_events() method returns -1 or the end_event_loop() method is invoked. Note that this method can only be used by the singleton ACE_Reactor::instance(). Thus, to run another reactor use ACE_Reactor::run_reactor_event_loop().

Deprecated:
Use ACE_Reactor::instance()->run_reactor_event_loop() instead
int ACE_Reactor::run_event_loop ( ACE_Time_Value tv)
inlinestatic

Run the event loop until the ACE_Reactor::handle_events() or <ACE_Reactor::alertable_handle_events> methods returns -1, the end_event_loop() method is invoked, or the ACE_Time_Value expires. Note that this method can only be used by the singleton ACE_Reactor::instance(). Thus, to run another reactor use <ACE_Reactor::run_reactor_event_loop>.

Deprecated:
Use ACE_Reactor::instance()->run_reactor_event_loop() instead
int ACE_Reactor::run_reactor_event_loop ( REACTOR_EVENT_HOOK  eh = 0)

Run the event loop until the ACE_Reactor::handle_events() or ACE_Reactor::alertable_handle_events() method returns -1 or the end_reactor_event_loop() method is invoked.

int ACE_Reactor::run_reactor_event_loop ( ACE_Time_Value tv,
REACTOR_EVENT_HOOK  eh = 0 
)

Run the event loop until the ACE_Reactor::handle_events() or ACE_Reactor::alertable_handle_events() method returns -1, the end_reactor_event_loop() method is invoked, or the ACE_Time_Value expires while the underlying event demultiplexer is waiting for events. Note that it is possible for events to continuously be available, avoiding the need to wait for events. In this situation the timeout value will not have an opportunity to expire until the next time the underlying event demultiplexer waits for events.

long ACE_Reactor::schedule_timer ( ACE_Event_Handler event_handler,
const void *  arg,
const ACE_Time_Value delay,
const ACE_Time_Value interval = ACE_Time_Value::zero 
)
virtual

Schedule a timer event.

Schedule a timer event that will expire after an delay 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.

Reactor will call ACE_Event_Handler::add_reference() on the handler. After the timeout occurs and ACE_Event_Handler::handle_timeout() has completed, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.

See Also
cancel_timer()
reset_timer_interval()
Parameters
event_handlerEvent handler to schedule on reactor. The handler's handle_timeout() method will be called when this scheduled timer expires.
argArgument passed to the handle_timeout() method of event_handler.
delayTime interval after which the timer will expire.
intervalTime interval for which the timer will be automatically rescheduled if the handle_timeout() callback does not return a value less than 0.
Return values
timerid, on success. The id can be used to cancel or reschedule this timer.
-1on failure, with errno set.

Implements ACE_Reactor_Timer_Interface.

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

int ACE_Reactor::schedule_wakeup ( ACE_HANDLE  handle,
ACE_Reactor_Mask  masks_to_be_added 
)
inline

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.

int ACE_Reactor::set_sig_handler ( ACE_Sig_Handler signal_handler)
inline

Use a user specified signal handler instead.

size_t ACE_Reactor::size ( void  ) const
inline

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

int ACE_Reactor::suspend_handler ( ACE_HANDLE  handle)
inline

Suspend handle temporarily.

int ACE_Reactor::suspend_handler ( ACE_Event_Handler event_handler)
inline

Suspend event_handler temporarily.

Handle is obtained from ACE_Event_Handler::get_handle().

int ACE_Reactor::suspend_handler ( const ACE_Handle_Set handles)
inline

Suspend handles temporarily.

Shorthand for calling suspend_handler(ACE_HANDLE) with multiple handles.

int ACE_Reactor::suspend_handlers ( void  )
inline

Suspend all registered handles temporarily.

int ACE_Reactor::timer_queue ( ACE_Timer_Queue tq)
inline

Set a user-specified timer queue.

ACE_Timer_Queue * ACE_Reactor::timer_queue ( void  ) const
inline

Return the current ACE_Timer_Queue.

bool ACE_Reactor::uses_event_associations ( void  )
inline

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

void ACE_Reactor::wakeup_all_threads ( void  )
inline

Wake up all threads in waiting in the event loop.

int ACE_Reactor::work_pending ( const ACE_Time_Value max_wait_time = ACE_Time_Value::zero)
inline

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.

bool ACE_Reactor::delete_implementation_
protected

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

bool ACE_Reactor::delete_reactor_ = false
staticprotected

Must delete the reactor_ singleton if true.

ACE_Reactor_Impl* ACE_Reactor::implementation_
protected

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

ACE_Reactor * ACE_Reactor::reactor_ = 0
staticprotected

Pointer to a process-wide ACE_Reactor singleton.


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