NAME

ACE_Reactor - An object oriented event demultiplexor and event handler dispatcher.

SYNOPSIS


#include <ace/Reactor.h>


class ACE_Reactor
{
  public:
        enum { DEFAULT_SIZE = ACE_DEFAULT_REACTOR_SIZE,
        GET_MASK = 1,
        SET_MASK = 2,
        ADD_MASK = 3,
        CLR_MASK = 4 };
        
    ACE_Reactor (ACE_Sig_Handler * = 0);
    ACE_Reactor (size_t size, int restart = 0, ACE_Sig_Handler * = 0);
    virtual int open (
        size_t size = DEFAULT_SIZE,
        int restart = 0,
        ACE_Sig_Handler * = 0
        );
    virtual void close (void);
    virtual ~ACE_Reactor (void);
    virtual int schedule_timer (
        ACE_Event_Handler *,
        const void *arg,
        const ACE_Time_Value &delta,
        const ACE_Time_Value &interval = ACE_Time_Value::zero
        );
    virtual int cancel_timer (ACE_Event_Handler *event_handler);
    virtual int cancel_timer (int timer_id, const void **arg = 0);
    virtual int handle_events (ACE_Time_Value *how_long = 0);
    virtual int handle_events (ACE_Time_Value &how_long);
    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 (
        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 resume_handler (ACE_Event_Handler *eh);
    virtual int resume_handler (ACE_HANDLE handle);
    virtual int suspend_handlers (void);
    virtual int resume_handlers (void);
    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 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 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 int notify (
        ACE_Event_Handler * = 0,
        ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK
        );
    void requeue_position (int);
    int requeue_position (void);
    void owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
    int owner (ACE_thread_t *);
    void dump (void) const;
    ACE_ALLOC_HOOK_DECLARE;
  protected:
    virtual int attach (
        ACE_HANDLE handle,
        ACE_Event_Handler *eh,
        ACE_Reactor_Mask mask
        );
    virtual int detach (ACE_HANDLE handle, ACE_Reactor_Mask);
    virtual int suspend (ACE_HANDLE handle);
    virtual int resume (ACE_HANDLE handle);
    virtual int remove_handlers (
        const ACE_Handle_Set &handles,
        ACE_Reactor_Mask
        );
    virtual int register_handlers (
        const ACE_Handle_Set &handles,
        ACE_Event_Handler *handler,
        ACE_Reactor_Mask mask
        );
    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 (void) const;
    virtual int handle_error (void);
    virtual int check_handles (void);
    virtual int bit_ops (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        ACE_Handle_Set &rd,
        ACE_Handle_Set &wr,
        ACE_Handle_Set &ex,
        int ops
        );
    virtual int fill_in_ready (
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        ACE_Handle_Set &
        );
    virtual int wait_for_multiple_events (
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        ACE_Time_Value *
        );
    virtual void dispatch (
        int,
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        ACE_Handle_Set &
        );
    virtual void notify_handle (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        ACE_Handle_Set &,
        ACE_Event_Handler *eh,
        ACE_EH_PTMF callback
        );
    ACE_Timer_Queue *timer_queue_;
    ACE_Handler_Repository handler_rep_;
    ACE_Sig_Handler *signal_handler_;
    int delete_signal_handler_;
    ACE_Handle_Set rd_handle_mask_;
    ACE_Handle_Set wr_handle_mask_;
    ACE_Handle_Set ex_handle_mask_;
    ACE_Handle_Set rd_handle_mask_ready_;
    ACE_Handle_Set wr_handle_mask_ready_;
    ACE_Handle_Set ex_handle_mask_ready_;
    int restart_;
    int requeue_position_;
    int initialized_;
    ACE_thread_t owner_;
    ACE_Notification_Handler notification_handler_;
    ACE_Reactor_Token token_;
    void renew (void);
    friend class ACE_Notification_Handler;
    friend class ACE_Handler_Repository;
    pollfd *handle_sets_to_poll_fds (ACE_HANDLE &width);
    void poll_fds_to_handle_sets (
        ACE_HANDLE width,
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        ACE_Handle_Set &,
        int nfound
        );
    pollfd *poll_h_;
  private:
    ACE_Time_Value timer_skew_;
    ACE_Reactor (const ACE_Reactor &);
    ACE_Reactor &operator = (const ACE_Reactor &);
};

DESCRIPTION

The ACE_Reactor is an object-oriented event demultiplexor and event handler dispatcher. The sources of events that the ACE_Reactor waits for and dispatches includes I/O events, signals, and timer events.

Initialization and termination methods.

ACE_Reactor (ACE_Sig_Handler * = 0);
ACE_Reactor (size_t size, int restart = 0, ACE_Sig_Handler * = 0);
virtual int open (
    size_t size = DEFAULT_SIZE,
    int restart = 0,
    ACE_Sig_Handler * = 0
    );
virtual void close (void);
virtual ~ACE_Reactor (void);

Timer management.

virtual int schedule_timer (
    ACE_Event_Handler *,
    const void *arg,
    const ACE_Time_Value &delta,
    const ACE_Time_Value &interval = ACE_Time_Value::zero
    );
virtual int cancel_timer (ACE_Event_Handler *event_handler);
virtual int cancel_timer (int timer_id, const void **arg = 0);

Event loop drivers.

virtual int handle_events (ACE_Time_Value *how_long = 0);
virtual int handle_events (ACE_Time_Value &how_long);

Register and remove Handlers.

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

Suspend and resume Handlers.

virtual int suspend_handler (ACE_Event_Handler *eh);
virtual int suspend_handler (ACE_HANDLE handle);
virtual int resume_handler (ACE_Event_Handler *eh);
virtual int resume_handler (ACE_HANDLE handle);
virtual int suspend_handlers (void);
virtual int resume_handlers (void);

Misc. Handler operations.

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

High-level Event_Handler scheduling operations

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

Low-level dispatch mask manipulation methods.

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

Ready bit manipulation methods.

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 int notify (
    ACE_Event_Handler * = 0,
    ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK
    );

Get/set position that the main ACE_Reactor thread is requeued

in the list of waiters during a notify() callback.
void requeue_position (int);
int requeue_position (void);

Get/set the current

owner" of the thread (i.e., the only" thread that can perform a handle_events()).
void owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
int owner (ACE_thread_t *);
void dump (void) const;
ACE_ALLOC_HOOK_DECLARE;

Internal methods that do the actual work (most of these

assume that locks are held).
virtual int attach (
    ACE_HANDLE handle,
    ACE_Event_Handler *eh,
    ACE_Reactor_Mask mask
    );
virtual int detach (ACE_HANDLE handle, ACE_Reactor_Mask);
virtual int suspend (ACE_HANDLE handle);
virtual int resume (ACE_HANDLE handle);
virtual int remove_handlers (
    const ACE_Handle_Set &handles,
    ACE_Reactor_Mask
    );
virtual int register_handlers (
    const ACE_Handle_Set &handles,
    ACE_Event_Handler *handler,
    ACE_Reactor_Mask mask
    );
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 (void) const;
virtual int handle_error (void);
virtual int check_handles (void);
virtual int bit_ops (
    ACE_HANDLE handle,
    ACE_Reactor_Mask mask,
    ACE_Handle_Set &rd,
    ACE_Handle_Set &wr,
    ACE_Handle_Set &ex,
    int ops
    );
virtual int fill_in_ready (
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    ACE_Handle_Set &
    );
virtual int wait_for_multiple_events (
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    ACE_Time_Value *
    );
virtual void dispatch (
    int,
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    ACE_Handle_Set &
    );
virtual void notify_handle (
    ACE_HANDLE handle,
    ACE_Reactor_Mask mask,
    ACE_Handle_Set &,
    ACE_Event_Handler *eh,
    ACE_EH_PTMF callback
    );
ACE_Timer_Queue *timer_queue_;
ACE_Handler_Repository handler_rep_;
ACE_Sig_Handler *signal_handler_;
int delete_signal_handler_;

Track which handles we are interested

for various types of (reading, writing, and exception) events. The following three Handle_Sets are waited for by poll() or select().
ACE_Handle_Set rd_handle_mask_;
ACE_Handle_Set wr_handle_mask_;
ACE_Handle_Set ex_handle_mask_;

Keep track of events that we'd like to have dispatched

*without* requiring poll() or select() to wait...
ACE_Handle_Set rd_handle_mask_ready_;
ACE_Handle_Set wr_handle_mask_ready_;
ACE_Handle_Set ex_handle_mask_ready_;
int restart_;
int requeue_position_;
int initialized_;
ACE_thread_t owner_;
ACE_Notification_Handler notification_handler_;
ACE_Reactor_Token token_;
void renew (void);
friend class ACE_Notification_Handler;
friend class ACE_Handler_Repository;

Convert to and from the select() to poll() types.

pollfd *handle_sets_to_poll_fds (ACE_HANDLE &width);
void poll_fds_to_handle_sets (
    ACE_HANDLE width,
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    ACE_Handle_Set &,
    int nfound
    );
pollfd *poll_h_;

AUTHOR

Doug Schmidt

LIBRARY

ace