EventHandler.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_EVENTHANDLER_HXX_
#define _OPENLCB_EVENTHANDLER_HXX_
 
#include <stdint.h>
 
#include "executor/Notifiable.hxx"
#include "utils/AsyncMutex.hxx"
#include "utils/macros.h"
#include "utils/Singleton.hxx"
#include "openlcb/WriteHelper.hxx"
 
namespace openlcb
{
 
typedef uint64_t EventId;
class Node;
class EventHandler;
 
/*enum EventMask {
  EVENT_EXACT_MASK = 1,
  EVENT_ALL_MASK = 0xffffffffffffffffULL
  };*/
 
enum TestingEnum
{
    FOR_TESTING
};
 
struct EventReport
{
    EventId event;
    EventId mask;
    NodeHandle src_node;
    Node *dst_node;
    EventState state;
 
    template <int N> WriteHelper *event_write_helper()
    {
        static_assert(1 <= N && N <= 4, "WriteHelper out of range.");
        return write_helpers + (N - 1);
    }
 
    EventReport(TestingEnum)
    {
    }
 
private:
    EventReport() {}
    friend class EventIteratorFlow;
    friend class DecoderRangeTest;
 
    WriteHelper write_helpers[4];
};
 
class EventRegistryEntry
{
public:
    EventId event;
    EventHandler *handler;
    uint32_t user_arg;
    EventRegistryEntry(EventHandler *_handler, EventId _event)
        : event(_event)
        , handler(_handler)
        , user_arg(0)
    {
    }
    EventRegistryEntry(EventHandler *_handler, EventId _event,
                       unsigned _user_arg)
        : event(_event)
        , handler(_handler)
        , user_arg(_user_arg)
    {
    }
};
 
class EventHandler
{
public:
    using EventReport = openlcb::EventReport;
    using EventRegistryEntry = openlcb::EventRegistryEntry;
    using EventId = openlcb::EventId;
 
    virtual ~EventHandler()
    {
    }
 
    virtual void handle_event_report(const EventRegistryEntry &registry_entry,
                                   EventReport *event,
                                   BarrierNotifiable *done) = 0;
 
    virtual void
    handle_consumer_identified(const EventRegistryEntry &registry_entry,
                             EventReport *event, BarrierNotifiable *done)
    {
        done->notify();
    };
 
    virtual void
    handle_consumer_range_identified(const EventRegistryEntry &registry_entry,
                                  EventReport *event, BarrierNotifiable *done)
    {
        done->notify();
    }
 
    virtual void
    handle_producer_identified(const EventRegistryEntry &registry_entry,
                             EventReport *event, BarrierNotifiable *done)
    {
        done->notify();
    }
 
    virtual void
    handle_producer_range_identified(const EventRegistryEntry &registry_entry,
                                  EventReport *event, BarrierNotifiable *done)
    {
        done->notify();
    }
 
    virtual void handle_identify_global(const EventRegistryEntry &registry_entry,
                                      EventReport *event,
                                      BarrierNotifiable *done) = 0;
 
    virtual void
    handle_identify_consumer(const EventRegistryEntry &registry_entry,
                           EventReport *event, BarrierNotifiable *done) = 0;
 
    virtual void
    handle_identify_producer(const EventRegistryEntry &registry_entry,
                           EventReport *event, BarrierNotifiable *done) = 0;
};
 
typedef void (EventHandler::*EventHandlerFunction)(
    const EventRegistryEntry &registry_entry, EventReport *event,
    BarrierNotifiable *done);
 
class EventIterator;
 
class EventRegistry : public Singleton<EventRegistry>
{
public:
    virtual ~EventRegistry();
 
    static unsigned align_mask(EventId *event, unsigned size);
 
    virtual void register_handler(const EventRegistryEntry &entry,
                                  unsigned mask) = 0;
    virtual void unregister_handler(EventHandler *handler,
        uint32_t user_arg = 0, uint32_t user_arg_mask = 0) = 0;
 
    virtual void reserve(size_t count)
    {
    }
 
    virtual EventIterator *create_iterator() = 0;
 
    unsigned get_epoch()
    {
        return dirtyCounter_;
    }
 
protected:
    EventRegistry();
 
    void set_dirty()
    {
        ++dirtyCounter_;
    }
 
private:
    static EventRegistry *instance_;
 
    unsigned dirtyCounter_ = 0;
 
    DISALLOW_COPY_AND_ASSIGN(EventRegistry);
};
 
}; /* namespace openlcb */
 
#endif // _OPENLCB_EVENTHANDLER_HXX_