xrb_eventqueue.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_eventqueue.hpp by Victor Dods, created 2005/02/15
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_EVENTQUEUE_HPP_)
#define _XRB_EVENTQUEUE_HPP_

#include "xrb.hpp"

#include <set>

#include "xrb_event.hpp"
#include "xrb_framehandler.hpp"

namespace Xrb
{

class EventHandler;

class EventQueue : public FrameHandler
{
public:

    EventQueue ();
    virtual ~EventQueue ();

    void EnqueueEvent (
        EventHandler *event_handler,
        Event const *event);
    void DeleteEventsBelongingToHandler (
        EventHandler *event_handler);
    void ScheduleMatchingEventsForDeletion (bool (*EventMatchingFunction)(Event const *));
    template <typename ParameterType>
    void ScheduleMatchingEventsForDeletion (
        bool (*EventMatchingFunction)(Event const *, ParameterType),
        ParameterType parameter);
    template <typename Parameter1Type, typename Parameter2Type>
    void ScheduleMatchingEventsForDeletion (
        bool (*EventMatchingFunction)(Event const *, Parameter1Type, Parameter2Type),
        Parameter1Type parameter1,
        Parameter2Type parameter2);
        
protected:

    virtual void HandleFrame ();

private:

    // the maximum ID number
    static inline Uint32 MaxEventID ()
    {
        return UINT32_UPPER_BOUND;
    }

    // stick the buffered event queue into the main event queue
    void EnqueueBufferedEvents ();
    // when m_current_id is
    void CompactEventIDs ();

    // the EventBinding class is used to pair events with event handlers
    class EventBinding
    {
    private:

        EventHandler *m_event_handler;
        Event const *m_event;

    public:

        EventBinding (
            EventHandler *const event_handler,
            Event const *const event)
        {
            m_event_handler = event_handler;
            m_event = event;
        }

        inline EventHandler *GetEventHandler () const
        {
            return m_event_handler;
        }
        inline Event const *GetEvent () const
        {
            return m_event;
        }
    }; // end of class EventBinding

    // the OrderEventBindingsByEventTime functor is used to provide a strict
    // weak ordering for event queues which should be ordered by event time
    struct OrderEventBindingsByEventTime
    {
        bool operator () (
            EventBinding const &left_operand,
            EventBinding const &right_operand) const;
    };

    typedef std::multiset<EventBinding, OrderEventBindingsByEventTime> TimeOrderedEventBindingSet;

    // the time-ordered queue of events (ordered by time and then ID)
    TimeOrderedEventBindingSet m_time_ordered_event_queue;
    // secondary time-ordered event queue, which event bindings are inserted
    // into before being added to the main event queue.  they will be inserted
    // into the main event queue before ProcessQueue actually does any
    // processing.
    TimeOrderedEventBindingSet m_buffered_time_ordered_event_queue;
    
    // the next available Event ID.  the event IDs are used to give a unique
    // ordering to the event queue.  the event queue is ordered primarily by
    // event time, but then secondarily by the ID (so that events with the same
    // time will be sorted in the order they were issued).
    Uint32 m_current_event_id;

}; // end of class EventQueue

template <typename ParameterType>
void EventQueue::ScheduleMatchingEventsForDeletion (
    bool (*EventMatchingFunction)(Event const *, ParameterType),
    ParameterType parameter)
{
    // check all enqueued events against the given event-matching function.
    for (TimeOrderedEventBindingSet::iterator it = m_time_ordered_event_queue.begin(),
                                            it_end = m_time_ordered_event_queue.end();
         it != it_end;
         ++it)
    {
        Event const *event = it->GetEvent();
        ASSERT1(event != NULL);
        // only check events that aren't already scheduled for deletion
        if (!event->IsScheduledForDeletion())
            // if the function indicates a match, schedule the event for deletion
            if (EventMatchingFunction(event, parameter))
                event->ScheduleForDeletion();
    }
}

template <typename Parameter1Type, typename Parameter2Type>
void EventQueue::ScheduleMatchingEventsForDeletion (
    bool (*EventMatchingFunction)(Event const *, Parameter1Type, Parameter2Type),
    Parameter1Type parameter1,
    Parameter2Type parameter2)
{
    // check all enqueued events against the given event-matching function.
    for (TimeOrderedEventBindingSet::iterator it = m_time_ordered_event_queue.begin(),
                                            it_end = m_time_ordered_event_queue.end();
         it != it_end;
         ++it)
    {
        Event const *event = it->GetEvent();
        ASSERT1(event != NULL);
        // only check events that aren't already scheduled for deletion
        if (!event->IsScheduledForDeletion())
            // if the function indicates a match, schedule the event for deletion
            if (EventMatchingFunction(event, parameter1, parameter2))
                event->ScheduleForDeletion();
    }
}

} // end of namespace Xrb

#endif // !defined(_XRB_EVENTQUEUE_HPP_)

---