EventHandlerTemplates.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_EVENTHANDLERTEMPLATES_HXX_
#define _OPENLCB_EVENTHANDLERTEMPLATES_HXX_
 
#include "openlcb/EventHandler.hxx"
#include "openlcb/WriteHelper.hxx"
#include "os/Gpio.hxx"
 
namespace openlcb
{
 
uint64_t EncodeRange(uint64_t begin, unsigned size);
 
class ProxyEventHandler : public EventHandler
{
public:
    virtual ~ProxyEventHandler()
    {
    }
 
    virtual void HandlerFn(EventHandlerFunction fn,
                           const EventRegistryEntry &registry_entry,
                           EventReport *event, BarrierNotifiable *done) = 0;
 
#define DEFPROXYFN(FN)                                                         \
    virtual void FN(const EventRegistryEntry &registry_entry,                  \
                    EventReport *event, BarrierNotifiable *done) override      \
    {                                                                          \
        HandlerFn(&EventHandler::FN, registry_entry, event, done);             \
    }
 
    DEFPROXYFN(handle_event_report);
    DEFPROXYFN(handle_consumer_identified);
    DEFPROXYFN(handle_consumer_range_identified);
    DEFPROXYFN(handle_producer_identified);
    DEFPROXYFN(handle_producer_range_identified);
    DEFPROXYFN(handle_identify_global);
    DEFPROXYFN(handle_identify_consumer);
    DEFPROXYFN(handle_identify_producer);
 
#undef DEFPROXYFN
};
 
class SimpleEventHandler : public EventHandler
{
public:
#define IGNOREFN(FN)                                                           \
    virtual void FN(const EventRegistryEntry &registry_entry,                  \
                    EventReport *event, BarrierNotifiable *done) override      \
    {                                                                          \
        done->notify();                                                        \
    }
 
    IGNOREFN(handle_event_report);
    IGNOREFN(handle_consumer_identified);
    IGNOREFN(handle_consumer_range_identified);
    IGNOREFN(handle_producer_identified);
    IGNOREFN(handle_producer_range_identified);
    IGNOREFN(handle_identify_consumer);
    IGNOREFN(handle_identify_producer);
 
#undef IGNOREFN
};
 
template <uint64_t EVENT_ID>
class FixedEventProducer : public SimpleEventHandler
{
public:
    FixedEventProducer(Node *node) : node_(node)
    {
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(this, EVENT_ID), 0);
    }
 
    ~FixedEventProducer()
    {
        EventRegistry::instance()->unregister_handler(this);
    }
 
    void handle_identify_global(const EventRegistryEntry &registry_entry, EventReport *event, BarrierNotifiable *done)
        OVERRIDE
    {
        if (event->dst_node && event->dst_node != node_)
        {
            return done->notify();
        }
        event->event_write_helper<1>()->WriteAsync(node_,
            openlcb::Defs::MTI_PRODUCER_IDENTIFIED_UNKNOWN,
            WriteHelper::global(), openlcb::eventid_to_buffer(EVENT_ID), done);
    }
 
    void handle_identify_producer(const EventRegistryEntry &registry_entry, EventReport *event, BarrierNotifiable *done)
        OVERRIDE
    {
        return handle_identify_global(registry_entry, event, done);
    }
 
private:
    Node *node_;
};
 
class BitEventInterface
{
public:
    BitEventInterface(uint64_t event_on, uint64_t event_off)
        : event_on_(event_on)
        , event_off_(event_off)
    {
    }
 
    virtual EventState get_current_state() = 0;
 
    virtual EventState get_requested_state()
    {
        return get_current_state();
    }
 
    virtual void set_state(bool new_value) = 0;
 
    uint64_t event_on()
    {
        return event_on_;
    }
 
    uint64_t event_off()
    {
        return event_off_;
    }
 
    virtual Node *node() = 0;
 
private:
    uint64_t event_on_;
    uint64_t event_off_;
 
    DISALLOW_COPY_AND_ASSIGN(BitEventInterface);
};
 
class DistributedBit : public BitEventInterface
{
public:
    DistributedBit(Node *node, uint64_t event_on, uint64_t event_off)
        : BitEventInterface(event_on, event_off)
        , node_(node)
        , state_(EventState::UNKNOWN)
        , requested_(EventState::INVALID)
    {
    }
 
    ~DistributedBit()
    {
    }
 
    Node *node() override
    {
        return node_;
    }
 
    EventState get_current_state() override
    {
        return state_;
    }
 
    EventState get_requested_state() override
    {
        return requested_;
    }
 
    void set_state(bool new_value) override
    {
        state_ = new_value ? EventState::VALID : EventState::INVALID;
    }
 
    void set_requested_state(bool new_value)
    {
        requested_ = new_value ? EventState::VALID : EventState::INVALID;
    }
 
    void toggle_state()
    {
        requested_ = state_ == EventState::UNKNOWN ? EventState::VALID :
                                                     invert_event_state(state_);
    }
 
private:
    Node *node_;
 
    EventState state_;
 
    EventState requested_;
 
    DISALLOW_COPY_AND_ASSIGN(DistributedBit);
};
 
class NetworkInitializedBit : public BitEventInterface {
public:
    NetworkInitializedBit(Node *node, uint64_t event_on, uint64_t event_off,
        bool default_local_state)
        : BitEventInterface(event_on, event_off)
        , node_(node)
        , isKnown_(0)
        , localState_(default_local_state ? 1 : 0)
    {
    }
 
    Node *node() override
    {
        return node_;
    }
 
    EventState get_current_state() override
    {
        if (!isKnown_) return EventState::UNKNOWN;
        if (localState_) return EventState::VALID;
        return EventState::INVALID;
    }
 
    bool get_local_state() {
        return localState_;
    }
 
    bool is_network_state_known() {
        return isKnown_;
    }
    
    void set_state(bool new_value) override
    {
        isKnown_ = 1;
        localState_ = new_value ? 1 : 0;
    }
 
    void toggle_state()
    {
        set_state(!get_local_state());
    }
    
protected:
    Node* node_;
    uint8_t isKnown_ : 1;
    uint8_t localState_ : 1;
};
 
class CallbackNetworkInitializedBit : public NetworkInitializedBit
{
public:
    CallbackNetworkInitializedBit(openlcb::Node *node, uint64_t event_on,
                                  uint64_t event_off, bool default_local_state)
        : NetworkInitializedBit(node, event_on, event_off, default_local_state)
    {
    }
 
    void set_change_callback(std::function<void()> cb)
    {
        callback_ = std::move(cb);
    }
 
    void set_state(bool new_value) override
    {
        openlcb::NetworkInitializedBit::set_state(new_value);
        if (callback_)
        {
            callback_();
        }
    }
 
    void reset()
    {
        isKnown_ = 0;
    }
    
private:
    std::function<void()> callback_;
};
 
 
template <class T> class MemoryBit : public BitEventInterface
{
public:
    MemoryBit(Node *node, uint64_t event_on, uint64_t event_off, T *ptr, T mask)
        : BitEventInterface(event_on, event_off)
        , node_(node)
        , ptr_(ptr)
        , mask_(mask)
    {
    }
 
    Node *node() override
    {
        return node_;
    }
    EventState get_current_state() override
    {
        return ((*ptr_) & mask_) ? EventState::VALID : EventState::INVALID;
    }
    void set_state(bool new_value) override
    {
        if (new_value)
        {
            *ptr_ |= mask_;
        }
        else
        {
            *ptr_ &= ~mask_;
        }
    }
 
private:
    Node *node_;
    T *ptr_;
    T mask_;
 
    DISALLOW_COPY_AND_ASSIGN(MemoryBit);
};
 
class GPIOBit : public BitEventInterface
{
public:
    GPIOBit(Node *node, EventId event_on, EventId event_off, const Gpio *gpio)
        : BitEventInterface(event_on, event_off)
        , node_(node)
        , gpio_(gpio)
    {
    }
 
    template <class HW>
    GPIOBit(Node *node, EventId event_on, EventId event_off, const HW &, const Gpio* g = HW::instance(), decltype(HW::instance)* = 0)
        : GPIOBit(node, event_on, event_off, g)
    {
    }
 
    EventState get_current_state() OVERRIDE
    {
        return gpio_->is_set() ? EventState::VALID : EventState::INVALID;
    }
    void set_state(bool new_value) OVERRIDE
    {
        gpio_->write(new_value);
    }
    Node *node() OVERRIDE
    {
        return node_;
    }
 
public:
    Node *node_;
    const Gpio *gpio_;
};
 
class BitEventHandler : public SimpleEventHandler
{
public:
    BitEventHandler(BitEventInterface *bit);
 
    void SendEventReport(WriteHelper *writer, Notifiable *done);
 
protected:
    void register_handler(uint64_t event_on, uint64_t event_off);
    void unregister_handler();
 
    void SendProducerIdentified(EventReport *event, BarrierNotifiable *done);
 
    void SendConsumerIdentified(EventReport *event, BarrierNotifiable *done);
 
    void HandlePCIdentify(Defs::MTI mti_valid, EventReport *event,
                          BarrierNotifiable *done);
 
    BitEventInterface *bit_;
 
private:
    enum {
        EVENT_ON = 1,
        EVENT_OFF = 2,
        BOTH_ON_IS_ZERO = 4,
        BOTH_OFF_IS_ZERO = 8,
    };
 
    DISALLOW_COPY_AND_ASSIGN(BitEventHandler);
};
 
class BitEventProducer : public BitEventHandler
{
public:
    BitEventProducer(BitEventInterface *bit) : BitEventHandler(bit)
    {
        register_handler(bit->event_on(), bit->event_off());
    }
    ~BitEventProducer()
    {
        unregister_handler();
    }
 
    void Update(WriteHelper *writer, Notifiable *done)
    {
        SendEventReport(writer, done);
    }
 
    void SendQuery(WriteHelper *writer, BarrierNotifiable *done);
 
    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:
    DISALLOW_COPY_AND_ASSIGN(BitEventProducer);
};
 
class BitEventConsumer : public BitEventHandler
{
public:
    BitEventConsumer(BitEventInterface *bit) : BitEventHandler(bit)
    {
        register_handler(bit->event_on(), bit->event_off());
    }
    ~BitEventConsumer()
    {
        unregister_handler();
    }
 
    void SendQuery(WriteHelper *writer, BarrierNotifiable *done);
 
    void handle_event_report(const EventRegistryEntry &entry, EventReport *event,
                           BarrierNotifiable *done) override;
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_producer_identified(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override;
};
 
class BitEventPC : public BitEventConsumer
{
public:
    BitEventPC(BitEventInterface *bit) : BitEventConsumer(bit)
    {
    }
 
    void SendQueryProducer(WriteHelper *writer, BarrierNotifiable *done)
    {
        SendQuery(writer, done);
    }
 
    void SendQueryConsumer(WriteHelper *writer, BarrierNotifiable *done);
 
    void handle_identify_producer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
    void handle_consumer_identified(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override;
};
 
class BitRangeEventPC : public SimpleEventHandler
{
public:
    BitRangeEventPC(Node *node, uint64_t event_base, uint32_t *backing_store,
                    unsigned size);
    virtual ~BitRangeEventPC();
 
    void Set(unsigned bit, bool new_value, WriteHelper *writer,
             BarrierNotifiable *done);
 
    bool Get(unsigned bit) const;
 
    void SendIdentified(WriteHelper *writer, BarrierNotifiable *done);
 
    void handle_event_report(const EventRegistryEntry &entry, EventReport *event,
                           BarrierNotifiable *done) override;
    void handle_identify_producer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
 
    unsigned size() { return size_; }
 
protected:
    void HandleIdentifyBase(Defs::MTI mti_valid, EventReport *event,
                            BarrierNotifiable *done);
    void GetBitAndMask(unsigned bit, uint32_t **data, uint32_t *mask) const;
 
    uint64_t event_base_;
    Node *node_;
    uint32_t *data_;
    unsigned size_; //< number of bits stored.
};
 
class BitRangeEventP : public BitRangeEventPC
{
public:
    BitRangeEventP(Node *node, uint64_t event_base, uint32_t *backing_store,
                   unsigned size)
        : BitRangeEventPC(node, event_base, backing_store, size)
    {
    }
 
    virtual ~BitRangeEventP()
    {
    }
 
    void handle_event_report(const EventRegistryEntry &entry, EventReport *event,
                             BarrierNotifiable *done) override
    {
        // Nothing to do for producers.
        done->notify();
    }
 
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override
    {
        // Nothing to do for producers.
        done->notify();
    }
 
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
};
 
class ByteRangeEventC : public SimpleEventHandler
{
public:
    ByteRangeEventC(Node *node, uint64_t event_base, uint8_t *backing_store,
                    unsigned size);
    virtual ~ByteRangeEventC();
 
    void SendIdentified(WriteHelper *writer, BarrierNotifiable *done);
 
    virtual void notify_changed(unsigned offset)
    {
    }
 
    void handle_event_report(const EventRegistryEntry &entry, EventReport *event,
                           BarrierNotifiable *done) override;
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
 
protected:
    bool DecodeEventId(uint64_t event_id, uint8_t **data, uint8_t *value);
 
    uint64_t event_base_;
    Node *node_;
    uint8_t *data_;
    unsigned size_; //< number of bytes consumed.
};
 
class ByteRangeEventP : public ByteRangeEventC
{
public:
    ByteRangeEventP(Node *node, uint64_t event_base, uint8_t *backing_store,
                    unsigned size);
 
    void Update(unsigned byte, WriteHelper *writer, BarrierNotifiable *done);
 
    void SendIdentified(WriteHelper *writer, BarrierNotifiable *done);
 
    // Need to override C behavior.
    void handle_event_report(const EventRegistryEntry &entry, EventReport *event,
                           BarrierNotifiable *done) override;
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    // Own behavior.
    void handle_identify_producer(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override;
    void handle_identify_global(const EventRegistryEntry &entry,
                              EventReport *event,
                              BarrierNotifiable *done) override;
    // Responses to possible queries.
    void handle_consumer_identified(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override;
    void handle_consumer_range_identified(const EventRegistryEntry &entry,
                                       EventReport *event,
                                       BarrierNotifiable *done) override;
 
private:
    uint64_t CurrentEventId(unsigned byte);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_EVENTHANDLERTEMPLATES_HXX_