---
name: "ACE_Select_Reactor_T"
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_Select_Reactor_T"
---

# ACE\_Select\_Reactor\_T(3)

An object oriented event demultiplexor and event handler dispatcher.

## NAME

ACE\_Select\_Reactor\_T -  An object oriented event demultiplexor and event handler dispatcher.

## SYNOPSIS

```
#include <ace/Select_Reactor_T.h>
template<class ACE_SELECT_REACTOR_TOKEN>
class ACE_Select_Reactor_T : public ACE_Select_Reactor_Impl
{
  public:
    ACE_Select_Reactor_T (
        ACE_Sig_Handler * = 0,
        ACE_Timer_Queue * = 0,
        int disable_notify_pipe = 0,
        ACE_Reactor_Notify *notify = 0,
        int mask_signals = 1
        );
    ACE_Select_Reactor_T (
        size_t size,
        int restart = 0,
        ACE_Sig_Handler * = 0,
        ACE_Timer_Queue * = 0,
        int disable_notify_pipe = 0,
        ACE_Reactor_Notify *notify = 0,
        int mask_signals = 1
        );
    virtual int open (
        size_t max_number_of_handles = DEFAULT_SIZE,
        int restart = 0,
        ACE_Sig_Handler * = 0,
        ACE_Timer_Queue * = 0,
        int disable_notify_pipe = 0,
        ACE_Reactor_Notify * = 0
        );
    virtual int current_info (ACE_HANDLE, size_t & );
    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 ~ACE_Select_Reactor_T (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 deactivated (void);
    virtual void deactivate (int do_stop);
    virtual int register_handler (
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask
        );
    virtual int register_handler (
        ACE_HANDLE handle,
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask
        );
    virtual int register_handler (
        ACE_Event_Handler *event_handler,
        ACE_HANDLE event_handle = ACE_INVALID_HANDLE
        );
    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 *eh,
        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 *eh,
        ACE_Reactor_Mask mask
        );
    virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask);
    virtual int remove_handler (
        const ACE_Handle_Set &handle_set,
        ACE_Reactor_Mask
        );
    virtual int remove_handler (
        int signum,
        ACE_Sig_Action *new_disp,
        ACE_Sig_Action *old_disp = 0,
        int sigkey = -1
        );
    virtual int remove_handler (const ACE_Sig_Set &sigset);
    virtual int suspend_handler (ACE_Event_Handler *eh);
    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 *eh);
    virtual int resume_handler (ACE_HANDLE handle);
    virtual int resume_handler (const ACE_Handle_Set &handles);
    virtual int resume_handlers (void);
    virtual int uses_event_associations (void);
    virtual long schedule_timer (
        ACE_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 *eh,
        ACE_Reactor_Mask mask
        );
    virtual int schedule_wakeup (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask
        );
    virtual int cancel_wakeup (
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask
        );
    virtual int cancel_wakeup (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask
        );
    virtual int notify (
        ACE_Event_Handler * = 0,
        ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK,
        ACE_Time_Value * = 0
        );
    virtual void max_notify_iterations (int);
    virtual int max_notify_iterations (void);
    virtual int restart (void);
    virtual int restart (int r);
    virtual void requeue_position (int);
    virtual int requeue_position (void);
    virtual int mask_ops (
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask,
        int ops
        );
    virtual int mask_ops (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        int ops
        );
    virtual int ready_ops (
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask,
        int ops
        );
    virtual int ready_ops (
        ACE_HANDLE handle,
        ACE_Reactor_Mask,
        int ops
        );
    virtual void wakeup_all_threads (void);
    virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
    virtual int owner (ACE_thread_t *);
    virtual int handler (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        ACE_Event_Handler **eh = 0
        );
    virtual int handler (int signum, ACE_Event_Handler ** = 0);
    virtual int initialized (void);
    virtual size_t size (void);
    virtual ACE_Lock &lock (void);
    virtual void dump (void) const;
    ACE_ALLOC_HOOK_DECLARE;
  protected:
    virtual int register_handler_i (
        ACE_HANDLE handle,
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask
        );
    virtual int register_handler_i (
        const ACE_Handle_Set &handles,
        ACE_Event_Handler *handler,
        ACE_Reactor_Mask mask
        );
    virtual int remove_handler_i (
        ACE_HANDLE handle,
        ACE_Reactor_Mask
        );
    virtual int remove_handler_i (
        const ACE_Handle_Set &handles,
        ACE_Reactor_Mask
        );
    virtual int suspend_i (ACE_HANDLE handle);
    virtual int resume_i (ACE_HANDLE handle);
    virtual int handler_i (
        ACE_HANDLE handle,
        ACE_Reactor_Mask,
        ACE_Event_Handler ** = 0
        );
    virtual int handler_i (int signum, ACE_Event_Handler ** = 0);
    virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set);
    virtual int any_ready_i (
        ACE_Select_Reactor_Handle_Set &handle_set
        );
    virtual int handle_error (void);
    virtual int check_handles (void);
    virtual int wait_for_multiple_events (
        ACE_Select_Reactor_Handle_Set &,
        ACE_Time_Value *
        );
    virtual int dispatch (
        int nfound,
        ACE_Select_Reactor_Handle_Set &
        );
    virtual int dispatch_timer_handlers (int &number_dispatched);
    virtual int dispatch_notification_handlers (
        ACE_Select_Reactor_Handle_Set &dispatch_set,
        int &number_of_active_handles,
        int &number_of_handlers_dispatched
        );
    virtual int dispatch_io_handlers (
        ACE_Select_Reactor_Handle_Set &dispatch_set,
        int &number_of_active_handles,
        int &number_of_handlers_dispatched
        );
    virtual int dispatch_io_set (
        int number_of_active_handles,
        int &number_of_handlers_dispatched,
        int mask,
        ACE_Handle_Set& dispatch_mask,
        ACE_Handle_Set& ready_mask,
        ACE_EH_PTMF callback
        );
    virtual void notify_handle (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        ACE_Handle_Set &,
        ACE_Event_Handler *eh,
        ACE_EH_PTMF callback
        );
    virtual void renew (void);
    ACE_SELECT_REACTOR_TOKEN token_;
    ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> lock_adapter_;
    int release_token (void);
    int handle_events_i (ACE_Time_Value *max_wait_time = 0);
    sig_atomic_t deactivated_;
    int mask_signals_;
  private:
    inline ACE_UNIMPLEMENTED_FUNC (
        ACE_Select_Reactor_T (const ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN> &)
        );
};
```

## DESCRIPTION

The ACE\_Select\_Reactor is an object-oriented event demultiplexor and event handler dispatcher.  The sources of events that the ACE\_Select\_Reactor waits for and dispatches includes I/O events, signals, and timer events.  All public methods acquire the main Select\_Reactor token lock and call down to private or protected methods, which assume that the lock is held and so therefore don't (re)acquire the lock.

## Initialization and termination methods.

```
ACE_Select_Reactor_T (
    ACE_Sig_Handler * = 0,
    ACE_Timer_Queue * = 0,
    int disable_notify_pipe = 0,
    ACE_Reactor_Notify *notify = 0,
    int mask_signals = 1
    );
```

Initialize ACE\_Select\_Reactor with the default size.

```
ACE_Select_Reactor_T (
    size_t size,
    int restart = 0,
    ACE_Sig_Handler * = 0,
    ACE_Timer_Queue * = 0,
    int disable_notify_pipe = 0,
    ACE_Reactor_Notify *notify = 0,
    int mask_signals = 1
    );
```

Initialize ACE\_Select\_Reactor with size size.

```
virtual int open (
    size_t max_number_of_handles = DEFAULT_SIZE,
    int restart = 0,
    ACE_Sig_Handler * = 0,
    ACE_Timer_Queue * = 0,
    int disable_notify_pipe = 0,
    ACE_Reactor_Notify * = 0
    );
```

Initialize the ACE\_Select\_Reactor to manage max\_number\_of\_handles.  If restart is non-0 then the ACE\_Reactor's handle\_events method will be restarted automatically when EINTR occurs.  If signal\_handler or timer\_queue are non-0 they are used as the signal handler and timer queue, respectively.  If disable\_notify\_pipe is non-0 the notification pipe is not created, thereby saving two I/O handles.

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

Returns -1 (not used in this implementation);

```
virtual int set_sig_handler (ACE_Sig_Handler *signal_handler);
```

Use a user specified signal handler instead.

```
virtual int set_timer_queue (ACE_Timer_Queue *timer_queue);
```

Use a user specified timer queue instead.

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

Close down the select\_reactor and release all of its resources.

```
virtual ~ACE_Select_Reactor_T (void);
```

Close down the select\_reactor and release all of its resources.

## 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 that blocks for max\_wait\_time before returning.  It will return earlier if timer events, I/O events, or signal events occur.  Note that max\_wait\_time can be 0, in which case this method blocks indefinitely until events occur.

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

Returns the total number of I/O and Timer ACE\_Event\_Handlers that were dispatched, 0 if the max\_wait\_time elapsed without dispatching any handlers, or -1 if something goes wrong.

Current alertable\_handle\_events is identical to handle\_events.

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

Current alertable\_handle\_events is identical to handle\_events.

## Event handling control.

```
virtual int deactivated (void);
```

Return the status of Reactor.  If this function returns 0, the reactor is actively handling events.  If it returns non-zero, handling\_events and handle\_alertable\_events return -1 immediately.

```
virtual void deactivate (int do_stop);
```

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

\= Register and remove ACE\_Event\_Handlers.

```
virtual int register_handler (
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

Register a eh with a particular mask.  Note that the Select\_Reactor will call ACE\_Event\_Handler::get\_handle to extract the underlying I/O handle.

```
virtual int register_handler (
    ACE_HANDLE handle,
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

Register a eh with a particular mask.  Note that since the handle is given the Select\_Reactor will \*not\* call ACE\_Event\_Handler::get\_handle to extract the underlying I/O handle.

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_Event_Handler *event_handler,
    ACE_HANDLE event_handle = ACE_INVALID_HANDLE
    );
```

Not implemented.

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

Not implemented.

```
virtual int register_handler (
    const ACE_Handle_Set &handles,
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

Register eh with all the handles in the Handle\_Set.

```
virtual int register_handler (
    int signum,
    ACE_Event_Handler *new_sh,
    ACE_Sig_Action *new_disp = 0,
    ACE_Event_Handler **old_sh = 0,
    ACE_Sig_Action *old_disp = 0
    );
```

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 *eh,
    ACE_Reactor_Mask mask
    );
```

Removes the mask binding of eh from the Select\_Reactor.  If there are no more bindings for this eh then it is removed from the Select\_Reactor.  Note that the Select\_Reactor will call ACE\_Event\_Handler::get\_handle to extract the underlying I/O handle.

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

Removes the mask bind of Event\_Handler whose handle is handle from the Select\_Reactor.  If there are no more bindings for this eh then it is removed from the Select\_Reactor.

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

Removes all the mask bindings for handles in the handle\_set bind of Event\_Handler.  If there are no more bindings for any of these handlers then they are removed from the Select\_Reactor.

```
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. sigkey is ignored in this implementation since there is only one instance of a signal handler.  Install the new disposition (if given) and return the previous disposition (if desired by the caller).  Returns 0 on success and -1 if signum is invalid.

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

Temporarily suspend the Event\_Handler associated with eh.

```
virtual int suspend_handler (ACE_HANDLE handle);
```

Temporarily suspend the Event\_Handler associated with handle.

```
virtual int suspend_handler (const ACE_Handle_Set &handles);
```

Suspend all handles in handle set temporarily.

```
virtual int suspend_handlers (void);
```

Suspend all the Event\_Handlers in the Select\_Reactor.

```
virtual int resume_handler (ACE_Event_Handler *eh);
```

Resume a temporarily suspend Event\_Handler associated with eh.

```
virtual int resume_handler (ACE_HANDLE handle);
```

Resume a temporarily suspended Event\_Handler associated with handle.

```
virtual int resume_handler (const ACE_Handle_Set &handles);
```

Resume all handles in handle set.

```
virtual int resume_handlers (void);
```

Resume all the Event\_Handlers in the Select\_Reactor.

```
virtual int uses_event_associations (void);
```

Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. Since the Select\_Reactor does not do any event associations, this function always return 0.

## Timer management.

```
virtual long schedule_timer (
    ACE_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 delta 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, which is 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.  If dont\_call\_handle\_close is 0 then the handle\_close method of event\_handler will be invoked. Returns number of handler's cancelled.

```
virtual int cancel_timer (
    long timer_id,
    const void **arg = 0,
    int dont_call_handle_close = 1
    );
```

Cancel the single ACE\_Event\_Handler that matches the timer\_id value (which was returned from the schedule method).  If arg is non-NULL then it will be set to point to the \`\`magic cookie'' argument passed in when the Event\_Handler was registered.  This makes it possible to free up the memory and avoid memory leaks. If dont\_call\_handle\_close is 0 then the handle\_close method of event\_handler will be invoked.  Returns 1 if cancellation succeeded and 0 if the timer\_id wasn't found.

## High-level Event\_Handler scheduling operations

```
virtual int schedule_wakeup (
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

ADD the dispatch MASK "bit" bound with the eh and the mask.

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

ADD the dispatch MASK "bit" bound with the handle and the mask.

```
virtual int cancel_wakeup (
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

CLR the dispatch MASK "bit" bound with the eh and the mask.

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

CLR the dispatch MASK "bit" bound with the handle and the mask.

## Notification methods.

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

Called by a thread when it wants to unblock the Select\_Reactor. This wakeups the ACE\_Select\_Reactor if currently blocked in select/poll.  Pass over both the Event\_Handler \*and\* the mask to allow the caller to dictate which Event\_Handler method the Select\_Reactor will invoke.  The ACE\_Time\_Value indicates how long to blocking trying to notify the Select\_Reactor.  If timeout == 0, the caller will block until action is possible, else will wait until the relative time specified in \*timeout elapses).

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

Set the maximum number of times that the ACE\_Select\_Reactor\_Notify::handle\_input method will iterate and dispatch the ACE\_Event\_Handlers that are passed in via the notify pipe before breaking out of its recv loop.  By default, this is set to -1, which means "iterate until the pipe is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead.

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

Get the maximum number of times that the ACE\_Select\_Reactor\_Notify::handle\_input method will iterate and dispatch the ACE\_Event\_Handlers that are passed in via the notify pipe before breaking out of its recv loop.

```
virtual int restart (void);
```

Get the existing restart value.

```
virtual int restart (int r);
```

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

```
virtual void requeue_position (int);
```

Set position that the main ACE\_Select\_Reactor thread is requeued in the list of waiters during a notify callback.

```
virtual int requeue_position (void);
```

Get position that the main ACE\_Select\_Reactor thread is requeued in the list of waiters during a notify callback.

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

```
virtual int mask_ops (
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask,
    int ops
    );
```

GET/SET/ADD/CLR the dispatch mask "bit" bound with the eh 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 *eh,
    ACE_Reactor_Mask mask,
    int ops
    );
```

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

```
virtual int ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops);
```

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

```
virtual void wakeup_all_threads (void);
```

Wake up all threads in waiting in the event loop

\= Only the owner thread that can perform a handle\_events.

```
virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
```

Set the new owner of the thread and return the old owner.

```
virtual int owner (ACE_thread_t *);
```

Return the current owner of the thread.

## Miscellaneous Handler operations.

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

Check to see if handle is associated with a valid Event\_Handler bound to mask.  Return the eh associated with this handler if eh != 0.

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

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

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

Returns true if we've 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 ACE\_Select\_Reactor\_Token that is used to serialize the internal Select\_Reactor's processing logic. This can be useful for situations where you need to avoid deadlock efficiently when ACE\_Event\_Handlers are used in multiple threads.

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

Dump the state of an object.

```
ACE_ALLOC_HOOK_DECLARE;
```

Declare the dynamic allocation hooks.

## Internal methods that do the actual work.

All of these methods assume that the Select\_Reactor's token lock is held by the public methods that call down to them.

```
virtual int register_handler_i (
    ACE_HANDLE handle,
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
```

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

```
virtual int register_handler_i (
    const ACE_Handle_Set &handles,
    ACE_Event_Handler *handler,
    ACE_Reactor_Mask mask
    );
```

Register a set of handles.

```
virtual int remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask);
```

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

```
virtual int remove_handler_i (
    const ACE_Handle_Set &handles,
    ACE_Reactor_Mask
    );
```

Remove a set of handles.

```
virtual int suspend_i (ACE_HANDLE handle);
```

Suspend the Event\_Handler associated with handle

```
virtual int resume_i (ACE_HANDLE handle);
```

Resume the Event\_Handler associated with handle

```
virtual int handler_i (
    ACE_HANDLE handle,
    ACE_Reactor_Mask,
    ACE_Event_Handler ** = 0
    );
```

Implement the public handler method.

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

Implement the public handler method.

```
virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set);
```

Check if there are any HANDLEs enabled in the ready\_set\_, and if so, update the handle\_set and return the number ready.  If there aren't any HANDLEs enabled return 0.

```
virtual int any_ready_i (ACE_Select_Reactor_Handle_Set &handle_set);
```

Implement the any\_ready method, assuming that the Sig\_Guard is beign held

```
virtual int handle_error (void);
```

Take corrective action when errors occur.

```
virtual int check_handles (void);
```

Make sure the handles are all valid.

```
virtual int wait_for_multiple_events (
    ACE_Select_Reactor_Handle_Set &,
    ACE_Time_Value *
    );
```

Wait for events to occur.

## Dispatching methods.

```
virtual int dispatch (int nfound, ACE_Select_Reactor_Handle_Set &);
```

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

```
virtual int dispatch_timer_handlers (int &number_dispatched);
```

Dispatch all timer handlers that have expired.  Returns -1 if the state of the wait\_set\_ has changed, else 0. number\_dispatched is set to the number of timer handlers dispatched.

```
virtual int dispatch_notification_handlers (
    ACE_Select_Reactor_Handle_Set &dispatch_set,
    int &number_of_active_handles,
    int &number_of_handlers_dispatched
    );
```

Dispatch any notification handlers.  Returns -1 if the state of the wait\_set\_ has changed, else returns number of handlers notified.

```
virtual int dispatch_io_handlers (
    ACE_Select_Reactor_Handle_Set &dispatch_set,
    int &number_of_active_handles,
    int &number_of_handlers_dispatched
    );
```

Dispatch all the input/output/except handlers that are enabled in the dispatch\_set.  Updates number\_of\_active\_handles and number\_of\_handlers\_dispatched according to the behavior of the number Returns -1 if the state of the wait\_set\_ has changed, else 0.

```
virtual int dispatch_io_set (
    int number_of_active_handles,
    int &number_of_handlers_dispatched,
    int mask,
    ACE_Handle_Set& dispatch_mask,
    ACE_Handle_Set& ready_mask,
    ACE_EH_PTMF callback
    );
```

Factors the dispatching of an io handle set (each WRITE, EXCEPT or READ set of handles).  It updates the number\_of\_handlers\_dispatched and invokes this-notify\_handle for all the handles in dispatch\_set using the mask, ready\_set and callback parameters.  Must return -1 if this-state\_changed otherwise it must return 0.

```
virtual void notify_handle (
    ACE_HANDLE handle,
    ACE_Reactor_Mask mask,
    ACE_Handle_Set &,
    ACE_Event_Handler *eh,
    ACE_EH_PTMF callback
    );
```

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

```
virtual void renew (void);
```

Enqueue ourselves into the list of waiting threads at the appropriate point specified by requeue\_position\_.

```
ACE_SELECT_REACTOR_TOKEN token_;
```

Synchronization token for the MT\_SAFE ACE\_Select\_Reactor.

```
ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> lock_adapter_;
```

Adapter used to return internal lock to outside world.

```
int release_token (void);
```

Release the token lock when a Win32 structured exception occurs.

```
int handle_events_i (ACE_Time_Value *max_wait_time = 0);
```

Stops the VC++ compiler from bitching about exceptions and destructors

```
sig_atomic_t deactivated_;
```

This flag is used to keep track of whether we are actively handling events or not.

```
int mask_signals_;
```

If 0 then the Reactor will not mask the signals during the event dispatching.  This is useful for applications that do not register any signal handlers and want to reduce the overhead introduce by the kernel level locks required to change the mask.

## AUTHOR

Doug Schmidt

## LIBRARY

ace