NonAuthoritativeEventProducer.hxx

 
#ifndef _OPENLCB_NONAUTHORITATIVEEVENTPRODUCER_HXX_
#define _OPENLCB_NONAUTHORITATIVEEVENTPRODUCER_HXX_
 
#include "openlcb/EventHandlerTemplates.hxx"
 
namespace openlcb
{
 
class BitRangeNonAuthoritativeEventP : public SimpleEventHandler
{
public:
    BitRangeNonAuthoritativeEventP(Node *node, uint64_t event_base,
                  uint32_t size,
                  std::function<void(unsigned, bool)> state_callback = nullptr)
        : node_(node)
        , eventBase_(event_base)
        , eventBaseOff_(0)
        , size_(size)
        , stateCallback_(state_callback)
    {
        unsigned mask = EventRegistry::align_mask(&event_base, size * 2);
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(this, event_base, EVENT_BASE), mask);
    }
 
    BitRangeNonAuthoritativeEventP(Node *node, uint64_t event_base_on,
                  uint64_t event_base_off, uint32_t size,
                  std::function<void(unsigned, bool)> state_callback = nullptr)
        : node_(node)
        , eventBaseOn_(event_base_on)
        , eventBaseOff_(event_base_off)
        , size_(size)
        , stateCallback_(state_callback)
    {
        unsigned mask;
 
        mask = EventRegistry::align_mask(&event_base_on, size);
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(this, event_base_on, EVENT_BASE_ON), mask);
 
        mask = EventRegistry::align_mask(&event_base_off, size);
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(this, event_base_off, EVENT_BASE_OFF), mask);
    }
 
    ~BitRangeNonAuthoritativeEventP()
    {
        EventRegistry::instance()->unregister_handler(this);
    }
 
    void send_query_consumer(unsigned bit, WriteHelper *writer,
                             BarrierNotifiable *done);
 
    void set(unsigned bit, bool new_value, WriteHelper *writer,
             BarrierNotifiable *done);
 
    void handle_event_report(const EventRegistryEntry &entry,
                             EventReport *event,
                             BarrierNotifiable *done) override;
 
    void handle_consumer_identified(const EventRegistryEntry &entry,
                                    EventReport *event,
                                    BarrierNotifiable *done) override;
 
    void handle_identify_global(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
 
    void handle_identify_producer(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override;
 
private:
    enum EventBaseType : unsigned
    {
        // start counting at 1 as 0 is reserved or unused
        EVENT_BASE = 1, 
        EVENT_BASE_ON, 
        EVENT_BASE_OFF, 
    };
 
    Node *node_; 
    union
    {
        uint64_t eventBase_; 
        uint64_t eventBaseOn_; 
    };
    uint64_t eventBaseOff_; 
    unsigned size_; 
 
    std::function<void(unsigned, bool)> stateCallback_;
 
    DISALLOW_COPY_AND_ASSIGN(BitRangeNonAuthoritativeEventP);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_AUTHORITATIVEEVENTPRODUCER_HXX_