---
name: "ACE_Reactor"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_Reactor"
---

# ACE\_Reactor(3)

The resposiblility of this class is to forward all methods to its delegation/implementation class, e.g., ACE\_Select\_Reactor or ACE\_WFMO\_Reactor.

## NAME

ACE\_Reactor -  The resposiblility of this class is to forward all methods to its delegation/implementation class, e.g., ACE\_Select\_Reactor or ACE\_WFMO\_Reactor.

## SYNOPSIS

```
#include <ace/Reactor.h>
class ACE_Reactor
{
  public:
    enum{ GET_MASK = 1, SET_MASK = 2, ADD_MASK = 3, CLR_MASK = 4 };
    typedef int (*REACTOR_EVENT_HOOK)(void*);
    static ACE_Reactor *instance (void);
    static ACE_Reactor *instance (
        ACE_Reactor *,
        int delete_reactor = 0
        );
    static void close_singleton (void);
    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 (void *);
    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);
    virtual void reset_reactor_event_loop (void);
    ACE_Reactor (
        ACE_Reactor_Impl *implementation = 0,
        int delete_implementation = 0
        );
    virtual ~ACE_Reactor (void);
    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);
    virtual int set_timer_queue (ACE_Timer_Queue *timer_queue);
    virtual int close (void);
    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
        );
    virtual int register_handler (
        ACE_HANDLE io_handle,
        ACE_Event_Handler *event_handler,
        ACE_Reactor_Mask mask
        );
    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
        );
    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 *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);
    virtual int suspend_handler (ACE_Event_Handler *event_handler);
    virtual int suspend_handler (ACE_HANDLE handle);
    virtual int suspend_handler (const ACE_Handle_Set &handles);
    virtual int suspend_handlers (void);
    virtual int resume_handler (ACE_Event_Handler *event_handler);
    virtual int resume_handler (ACE_HANDLE handle);
    virtual int resume_handler (const ACE_Handle_Set &handles);
    virtual int resume_handlers (void);
    virtual long 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 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 *event_handler,
        ACE_Reactor_Mask masks_to_be_added
        );
    virtual int schedule_wakeup (
        ACE_HANDLE handle,
        ACE_Reactor_Mask masks_to_be_added
        );
    virtual int cancel_wakeup (
        ACE_Event_Handler *event_handler,
        ACE_Reactor_Mask masks_to_be_cleared
        );
    virtual int cancel_wakeup (
        ACE_HANDLE handle,
        ACE_Reactor_Mask masks_to_be_cleared
        );
    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 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);
    virtual size_t size (void);
    virtual ACE_Lock &lock (void);
    virtual void wakeup_all_threads (void);
    virtual int owner (
        ACE_thread_t new_owner,
        ACE_thread_t *old_owner = 0
        );
    virtual int owner (ACE_thread_t *owner);
    virtual void requeue_position (int position);
    virtual int requeue_position (void);
    virtual int restart (void);
    virtual int restart (int r);
    virtual int mask_ops (
        ACE_Event_Handler *event_handler,
        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 *event_handler,
        ACE_Reactor_Mask mask,
        int ops
        );
    virtual int ready_ops (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        int ops
        );
    virtual ACE_Reactor_Impl *implementation (void);
    virtual int current_info (ACE_HANDLE handle, size_t &msg_size);
    virtual int uses_event_associations (void);
    ACE_ALLOC_HOOK_DECLARE;
    void dump (void) const;
  protected:
    virtual void implementation (ACE_Reactor_Impl *implementation);
    ACE_Reactor_Impl *implementation_;
    int delete_implementation_;
    static ACE_Reactor *reactor_;
    static int delete_reactor_;
    ACE_Reactor (const ACE_Reactor &);
    ACE_Reactor &operator = (const ACE_Reactor &);
};
```

## Singleton reactor event loop management methods.

Note that these method ONLY work on the "Singleton Reactor," i.e., the one returned from ACE\_Reactor::instance.

```
static int run_event_loop (void);
```

```
static int run_alertable_event_loop (void);
```

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.

```
static int run_event_loop (ACE_Time_Value &tv);
```

```
static int run_alertable_event_loop (ACE_Time_Value &tv);
```

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.

```
static int end_event_loop (void);
```

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.

```
static int event_loop_done (void);
```

Report if the ACE\_Reactor::instance's event loop is finished.

```
static void reset_event_loop (void);
```

Resets the ACE\_Reactor::end\_event\_loop\_ static so that the run\_event\_loop method can be restarted.

```
static int check_reconfiguration (void *);
```

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

## Reactor event loop management methods.

These methods work with an instance of a reactor.

```
virtual int run_reactor_event_loop (REACTOR_EVENT_HOOK = 0);
```

```
virtual int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK = 0);
```

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.

```
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
    );
```

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.

```
virtual int end_reactor_event_loop (void);
```

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.

```
virtual int reactor_event_loop_done (void);
```

Report if the ACE\_Reactor::instance's event loop is finished.

```
virtual void reset_reactor_event_loop (void);
```

Resets the ACE\_Reactor::end\_event\_loop\_ static so that the run\_event\_loop method can be restarted.

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

```
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
    );
```

Initialize the ACE\_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.

```
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 *timer_queue);
```

Use a user specified timer queue instead. Notice that I don't think you should mess with timer queue once the Reactor is up and running.

```
virtual int close (void);
```

Close down and release all resources.

## Event loop drivers.

```
virtual int work_pending (
    const ACE_Time_Value &max_wait_time = ACE_Time_Value::zero
    );
```

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

```
virtual int handle_events (ACE_Time_Value *max_wait_time = 0);
```

```
virtual int alertable_handle_events (
    ACE_Time_Value *max_wait_time = 0
    );
```

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.

```
virtual int handle_events (ACE_Time_Value &max_wait_time);
```

```
virtual int alertable_handle_events (ACE_Time_Value &max_wait_time);
```

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.

## Register and remove Handlers.

```
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
    );
```

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.

```
virtual int register_handler (
    ACE_HANDLE event_handle,
    ACE_HANDLE io_handle,
    ACE_Event_Handler *event_handler,
    ACE_Reactor_Mask mask
    );
```

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.

```
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
    );
```

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.

```
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
    );
```

Removes event\_handler.  Note that the I/O handle will be obtained using get\_handle method of event\_handler .  If mask == ACE\_Event\_Handler::DONT\_CALL then the handle\_close method of the event\_handler is not invoked.

```
virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask);
```

Removes handle.  If mask == ACE\_Event\_Handler::DONT\_CALL then the handle\_close method of the associated event\_handler is not invoked.

```
virtual int remove_handler (
    const ACE_Handle_Set &handle_set,
    ACE_Reactor_Mask mask
    );
```

Removes all handles in handle\_set.  If mask == ACE\_Event\_Handler::DONT\_CALL then the handle\_close method of the associated event\_handlers is not invoked.

```
virtual int remove_handler (
    int signum,
    ACE_Sig_Action *new_disp,
    ACE_Sig_Action *old_disp = 0,
    int sigkey = -1
    );
```

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.

```
virtual int remove_handler (const ACE_Sig_Set &sigset);
```

Calls remove\_handler for every signal in sigset.

## Suspend and resume Handlers.

```
virtual int suspend_handler (ACE_Event_Handler *event_handler);
```

Suspend event\_handler temporarily.  Use ACE\_Event\_Handler::get\_handle 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 ACE\_Event\_Handler::get\_handle 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.

## Timer management.

```
virtual long schedule_timer (
    ACE_Event_Handler *event_handler,
    const void *arg,
    const ACE_Time_Value &delta,
    const ACE_Time_Value &interval = ACE_Time_Value::zero
    );
```

Schedule an event\_handler that will expire after delay amount of time, which is specified as relative time to the current gettimeofday.  If it expires then arg is passed in as the value to the event\_handler's handle\_timeout callback method. If interval is != to ACE\_Time\_Value::zero then it is used to reschedule the event\_handler automatically, also specified using relative time.  This method returns a timer\_id that uniquely identifies the event\_handler in an internal list. This timer\_id can be used to cancel an event\_handler before it expires.  The cancellation ensures that timer\_ids are unique up to values of greater than 2 billion timers.  As long as timers don't stay around longer than this there should be no problems with accidentally deleting the wrong timer.  Returns -1 on failure (which is guaranteed never to be a valid timer\_id.

```
virtual int reset_timer_interval (
    long timer_id,
    const ACE_Time_Value &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.

```
virtual int cancel_timer (
    ACE_Event_Handler *event_handler,
    int dont_call_handle_close = 1
    );
```

Cancel all Event\_Handlers 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
    );
```

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.

## High-level Event\_Handler scheduling operations

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

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

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

```
virtual int cancel_wakeup (
    ACE_HANDLE handle,
    ACE_Reactor_Mask masks_to_be_cleared
    );
```

Clear masks\_to\_be\_cleared from the handle's entry.

## Notification methods.

```
virtual int notify (
    ACE_Event_Handler *event_handler = 0,
    ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK,
    ACE_Time_Value *tv = 0
    );
```

Notify event\_handler of mask event.  The ACE\_Time\_Value 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).

```
virtual void max_notify_iterations (int iterations);
```

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.

```
virtual int max_notify_iterations (void);
```

Get the maximum number of times that the 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.

## Assorted helper methods.

```
virtual int handler (
    ACE_HANDLE handle,
    ACE_Reactor_Mask mask,
    ACE_Event_Handler **event_handler = 0
    );
```

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.

```
virtual int handler (
    int signum,
    ACE_Event_Handler **event_handler = 0
    );
```

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.

```
virtual int initialized (void);
```

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

```
virtual size_t size (void);
```

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

```
virtual ACE_Lock &lock (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.

## Low-level wait\_set mask manipulation methods.

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

## Low-level ready\_set mask manipulation methods.

```
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_Impl *implementation (void);
```

Get the implementation class

```
virtual int current_info (ACE_HANDLE handle, size_t &msg_size);
```

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.

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

```
ACE_ALLOC_HOOK_DECLARE;
```

Declare the dynamic allocation hooks.

```
void dump (void) const;
```

Dump the state of the object.

## AUTHOR

Irfan Pyarali

## LIBRARY

ace