CallbackEventHandler.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CALLBACKEVENTHANDLER_HXX_
#define _OPENLCB_CALLBACKEVENTHANDLER_HXX_
 
#include <functional>
 
#include "openlcb/EventHandlerTemplates.hxx"
 
namespace openlcb
{
 
class CallbackEventHandler : public SimpleEventHandler
{
public:
    typedef std::function<void(const EventRegistryEntry &registry_entry,
        EventReport *report, BarrierNotifiable *done)> EventReportHandlerFn;
    typedef std::function<EventState(const EventRegistryEntry &registry_entry,
        EventReport *report)> EventStateHandlerFn;
    typedef std::function<void(openlcb::Defs::MTI mti,
        const EventRegistryEntry &registry_entry, EventReport *report,
        BarrierNotifiable *done)>
        EventIdentifiedHandlerFn;
 
    enum RegistryEntryBits
    {
        IS_PRODUCER = (1U << 31),
        IS_CONSUMER = (1U << 30),
        USER_BIT_MASK = IS_CONSUMER - 1,
    };
 
    CallbackEventHandler(Node *node, EventReportHandlerFn report_handler,
        EventStateHandlerFn state_handler = nullptr,
        EventIdentifiedHandlerFn identified_handler = nullptr)
        : reportHandler_(std::move(report_handler))
        , stateHandler_(std::move(state_handler))
        , identifiedHandler_(std::move(identified_handler))
        , node_(node)
    {
    }
 
    ~CallbackEventHandler()
    {
        remove_all_entries();
    }
 
    void add_entry(EventId event, uint32_t entry_bits)
    {
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(this, event, entry_bits), 0);
    }
 
    void remove_all_entries()
    {
        EventRegistry::instance()->unregister_handler(this);
    }
 
    void remove_entry(uint32_t entry_bits)
    {
        EventRegistry::instance()->unregister_handler(
            this, entry_bits, 0xFFFFFFFFu);
    }
 
    Node *node()
    {
        return node_;
    }
 
    void handle_event_report(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (reportHandler_)
        {
            reportHandler_(entry, event, done);
        }
        done->notify();
    }
 
    void handle_identify_consumer(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (registry_entry.user_arg & IS_CONSUMER)
        {
            send_consumer_identified(registry_entry, event, done);
        }
        done->notify();
    };
 
    void handle_identify_producer(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (registry_entry.user_arg & IS_PRODUCER)
        {
            send_producer_identified(registry_entry, event, done);
        }
        done->notify();
    };
 
    void handle_identify_global(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (registry_entry.user_arg & IS_PRODUCER)
        {
            send_producer_identified(registry_entry, event, done);
        }
        if (registry_entry.user_arg & IS_CONSUMER)
        {
            send_consumer_identified(registry_entry, event, done);
        }
        done->notify();
    };
 
    void handle_producer_identified(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (identifiedHandler_)
        {
            identifiedHandler_(
                Defs::MTI::MTI_PRODUCER_IDENTIFIED_UNKNOWN, entry, event, done);
        }
        done->notify();
    }
 
    void handle_consumer_identified(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        if (identifiedHandler_)
        {
            identifiedHandler_(
                Defs::MTI::MTI_CONSUMER_IDENTIFIED_UNKNOWN, entry, event, done);
        }
        done->notify();
    }
 
protected:
    void send_producer_identified(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done)
    {
        EventState state =
            stateHandler_ ? stateHandler_(entry, event) : EventState::UNKNOWN;
        Defs::MTI mti = Defs::MTI_PRODUCER_IDENTIFIED_VALID + state;
        event->event_write_helper<1>()->WriteAsync(node_, mti,
            WriteHelper::global(), eventid_to_buffer(entry.event),
            done->new_child());
    }
 
    void send_consumer_identified(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done)
    {
        EventState state =
            stateHandler_ ? stateHandler_(entry, event) : EventState::UNKNOWN;
        Defs::MTI mti = Defs::MTI_CONSUMER_IDENTIFIED_VALID + state;
        event->event_write_helper<3>()->WriteAsync(node_, mti,
            WriteHelper::global(), eventid_to_buffer(entry.event),
            done->new_child());
    }
 
private:
    EventReportHandlerFn reportHandler_;
    EventStateHandlerFn stateHandler_;
    EventIdentifiedHandlerFn identifiedHandler_;
    Node *node_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CALLBACKEVENTHANDLER_HXX_