## NAME

ACE_Reactor_Notify - Abstract class for unblocking an `ACE_Reactor_Impl` from its event loop.

## SYNOPSIS

    #include <ace/Reactor_Impl.h>

    class ACE_Reactor_Notify : public ACE_Event_Handler
    {
      public:
        virtual int open (
            ACE_Reactor_Impl *,
            ACE_Timer_Queue *timer_queue = 0,
            int disable_notify = 0
            ) = 0;
        virtual int close (void) = 0;
        virtual ssize_t notify (
            ACE_Event_Handler * = 0,
            ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK,
            ACE_Time_Value * = 0
            ) = 0;
        virtual int dispatch_notifications (
            int &number_of_active_handles,
            ACE_Handle_Set &rd_mask
            ) = 0;
        virtual void max_notify_iterations (int) = 0;
        virtual int max_notify_iterations (void) = 0;
        virtual void dump (void) const = 0;
    };

## Initialization and termination methods.

    virtual int open (
        ACE_Reactor_Impl *,
        ACE_Timer_Queue *timer_queue = 0,
        int disable_notify = 0
        ) = 0;

    virtual int close (void) = 0;

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

Called by a thread when it wants to unblock the `Reactor_Impl`. This wakeups the `Reactor_Impl` if currently blocked. Pass over both the `Event_Handler` *and* the `mask` to allow the caller to dictate which `Event_Handler` method the `Reactor_Impl` will invoke. The `ACE_Time_Value` indicates how long to blocking trying to notify the `Reactor_Impl`. If `timeout` == 0, the caller will block until action is possible, else will wait until the relative time specified in *`timeout` elapses).

    virtual int dispatch_notifications (
        int &number_of_active_handles,
        ACE_Handle_Set &rd_mask
        ) = 0;

Handles pending threads (if any) that are waiting to unblock the `Reactor_Impl`.

    virtual void max_notify_iterations (int) = 0;

Set the maximum number of times that the `handle_input` method will iterate and dispatch the `ACE_Event_Handlers` that are passed in via the notify queue before breaking out of the event 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) = 0;

Get the maximum number of times that the `handle_input` method will iterate and dispatch the `ACE_Event_Handlers` that are passed in via the notify queue before breaking out of its event loop.

    virtual void dump (void) const = 0;

Dump the state of an object.

## AUTHOR

Irfan Pyarali

## LIBRARY

ace