EventServiceImpl.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_EVENTSERVICEIMPL_HXX_
#define _OPENLCB_EVENTSERVICEIMPL_HXX_
 
#include <memory>
#include <vector>
 
#include "openlcb/EventService.hxx"
#include "openlcb/EventHandler.hxx"
 
namespace openlcb
{
 
class IncomingEventFlow;
class GlobalIdentifyFlow;
class EventHandler;
 
struct EventHandlerCall
{
    const EventRegistryEntry *registry_entry;
    EventReport *rep;
    EventHandlerFunction fn;
    unsigned epoch;
    void reset(const EventRegistryEntry *entry, unsigned epoch,
        EventReport *rep, EventHandlerFunction fn)
    {
        this->registry_entry = entry;
        this->rep = rep;
        this->fn = fn;
        this->epoch = epoch;
    }
};
 
class EventCallerFlow : public StateFlow<Buffer<EventHandlerCall>, QList<5>>
{
public:
    EventCallerFlow(Service *service)
        : StateFlow<Buffer<EventHandlerCall>, QList<5>>(service) {};
 
private:
    virtual Action entry() OVERRIDE;
    Action call_done();
 
    BarrierNotifiable n_;
};
 
class EventService::Impl
{
public:
    Impl(EventService *service);
    ~Impl();
 
    std::unique_ptr<EventRegistry> registry;
 
    std::vector<std::unique_ptr<StateFlowWithQueue>> ownedFlows_;
 
    EventCallerFlow callerFlow_;
 
    enum
    {
        // These address/mask should match all the messages carrying an event
        // id.
        MTI_VALUE_EVENT = Defs::MTI_EVENT_MASK,
        MTI_MASK_EVENT = Defs::MTI_EVENT_MASK,
        MTI_VALUE_GLOBAL = Defs::MTI_EVENTS_IDENTIFY_GLOBAL,
        MTI_MASK_GLOBAL = 0xffff,
        MTI_VALUE_ADDRESSED_ALL = Defs::MTI_EVENTS_IDENTIFY_ADDRESSED,
        MTI_MASK_ADDRESSED_ALL = 0xffff,
    };
};
 
class EventIteratorFlow : public IncomingMessageStateFlow
{
public:
    EventIteratorFlow(If *iface, EventService *event_service,
                      unsigned mti_value, unsigned mti_mask);
    ~EventIteratorFlow();
 
protected:
    Action entry() OVERRIDE;
    Action iterate_next();
 
private:
    virtual Action dispatch_event(const EventRegistryEntry *entry);
 
protected:
    EventService *eventService_;
 
    EventReport eventReport_;
 
    EventIterator *iterator_;
    Notifiable *incomingDone_;
    unsigned eventRegistryEpoch_;
 
    BarrierNotifiable n_;
    EventHandlerFunction fn_;
 
#ifdef DEBUG_EVENT_PERFORMANCE
    static const int REPORT_COUNT = 100;
    uint8_t countEvents_{0};
    uint16_t mtiValue_;
    long long numProcessNsec_{0};
    long long currentProcessStart_{0};
#endif
};
 
class InlineEventIteratorFlow : public EventIteratorFlow
{
public:
    InlineEventIteratorFlow(If *iface, EventService *event_service,
                            unsigned mti_value, unsigned mti_mask)
        : EventIteratorFlow(iface, event_service, mti_value, mti_mask)
    {
    }
 
private:
    Action dispatch_event(const EventRegistryEntry *entry) OVERRIDE;
 
    const EventRegistryEntry *currentEntry_{nullptr};
};
 
} // namespace openlcb
 
#endif // _OPENLCB_EVENTSERVICEIMPL_HXX_