ACE_Select_Reactor_Impl(3)

NAME

ACE_Select_Reactor_Impl - This class simply defines how Select_Reactor's basic interface functions should look like and provides a common base class for Select_Reactor using various locking mechanism.

SYNOPSIS

#include <ace/Select_Reactor_Base.h>
class ACE_Select_Reactor_Impl : public ACE_Reactor_Impl
{
  public:
    enum{ DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE };
    ACE_Select_Reactor_Impl (void);
    friend class ACE_Select_Reactor_Notify;
    friend class ACE_Select_Reactor_Handler_Repository;
  protected:
    virtual int bit_ops (
        ACE_HANDLE handle,
        ACE_Reactor_Mask mask,
        ACE_Select_Reactor_Handle_Set &wait_Set,
        int ops
        );
    virtual void renew (void) = 0;
    ACE_Select_Reactor_Handler_Repository handler_rep_;
    ACE_Select_Reactor_Handle_Set wait_set_;
    ACE_Select_Reactor_Handle_Set suspend_set_;
    ACE_Select_Reactor_Handle_Set ready_set_;
    ACE_Timer_Queue *timer_queue_;
    int delete_timer_queue_;
    ACE_Sig_Handler *signal_handler_;
    int delete_signal_handler_;
    ACE_Reactor_Notify *notify_handler_;
    int delete_notify_handler_;
    int restart_;
    int requeue_position_;
    int initialized_;
    ACE_thread_t owner_;
    int state_changed_;
    int supress_notify_renew (void);
    void supress_notify_renew (int sr);
  private:
    int supress_renew_;
    ACE_Select_Reactor_Impl (const ACE_Select_Reactor_Impl &);
    ACE_Select_Reactor_Impl &operator = (
        const ACE_Select_Reactor_Impl &
        );
};

PUBLIC MEMBERS

ACE_Select_Reactor_Impl (void);

Constructor.

friend class ACE_Select_Reactor_Notify;

friend class ACE_Select_Reactor_Handler_Repository;

PROTECTED MEMBERS

virtual int bit_ops (
    ACE_HANDLE handle,
    ACE_Reactor_Mask mask,
    ACE_Select_Reactor_Handle_Set &wait_Set,
    int ops
    );

Allow manipulation of the wait_set_ mask and ready_set_ mask.

virtual void renew (void) = 0;

Enqueue ourselves into the list of waiting threads at the appropriate point specified by requeue_position_.

ACE_Select_Reactor_Handler_Repository handler_rep_;

Table that maps ACE_HANDLEs to ACE_Event_Handler *'s.

ACE_Select_Reactor_Handle_Set wait_set_;

Tracks handles that are waited for by select.

ACE_Select_Reactor_Handle_Set suspend_set_;

Tracks handles that are currently suspended.

ACE_Select_Reactor_Handle_Set ready_set_;

Track HANDLES we are interested in for various events that must be dispatched *without* going through select.

ACE_Timer_Queue *timer_queue_;

Defined as a pointer to allow overriding by derived classes...

int delete_timer_queue_;

Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).

ACE_Sig_Handler *signal_handler_;

Handle signals without requiring global/static variables.

int delete_signal_handler_;

Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).

ACE_Reactor_Notify *notify_handler_;

Callback object that unblocks the ACE_Select_Reactor if it's sleeping.

int delete_notify_handler_;

Keeps track of whether we need to delete the notify handler (if we didn't create it, then we don't delete it).

int restart_;

Restart the handle_events event-loop method automatically when select is interrupted via EINTR.

int requeue_position_;

Position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a notify callback. If this value == -1 we are requeued at the end of the list. Else if it's 0 then we are requeued at the front of the list. Else if it's 1 then that indicates the number of waiters to skip over.

int initialized_;

True if we've been initialized yet...

ACE_thread_t owner_;

The original thread that created this Select_Reactor.

int state_changed_;

True if state has changed during dispatching of ACE_Event_Handlers, else false. This is used to determine whether we need to make another trip through the Select_Reactor's wait_for_multiple_events loop.

int supress_notify_renew (void);

void supress_notify_renew (int sr);

Controls/access whether the notify handler should renew the Select_Reactor's token or not.

PRIVATE MEMBERS

int supress_renew_;

Determine whether we should renew Select_Reactor's token after handling the notification message.

ACE_Select_Reactor_Impl (const ACE_Select_Reactor_Impl &);

ACE_Select_Reactor_Impl &operator = (const ACE_Select_Reactor_Impl &);

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

AUTHOR

Doug Schmidt

LIBRARY

ace