EventHandlerContainer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_EVENTHANDLERCONTAINER_HXX_
#define _OPENLCB_EVENTHANDLERCONTAINER_HXX_
 
#include <algorithm>
#include <vector>
#include <forward_list>
#include <stdint.h>
#include <endian.h>
 
#ifndef LOGLEVEL
//#define LOGLEVEL VERBOSE
#endif
 
#include "utils/Atomic.hxx"
#include "utils/logging.h"
#include "utils/SortedListMap.hxx"
#include "openlcb/EventHandler.hxx"
#include "openlcb/EventHandlerTemplates.hxx"
 
namespace openlcb
{
 
class EventIterator {
protected:
    EventIterator() {}
 
public:
    virtual ~EventIterator() {}
 
    virtual EventRegistryEntry* next_entry() = 0;
 
    virtual void init_iteration(EventReport* event) = 0;
 
    virtual void clear_iteration() = 0;
};
 
template<class C> class FullContainerIterator : public EventIterator {
public:
    FullContainerIterator(C* container)
        : container_(container) {
        clear_iteration();
    }
    EventRegistryEntry* next_entry() OVERRIDE {
        if (it_ == container_->end()) return nullptr;
        EventRegistryEntry* h = &*it_;
        ++it_;
        return h;
    }
    void clear_iteration() OVERRIDE {
        it_ = container_->end();
    }
    void init_iteration(EventReport*) OVERRIDE {
        it_ = container_->begin();
    }
 
private:
    typename C::iterator it_;
    C* container_;
};
 
class VectorEventHandlers : public EventRegistry, private Atomic
{
public:
    VectorEventHandlers() {}
 
    // Creates a new event iterator. Caller takes ownership of object.
    EventIterator* create_iterator() OVERRIDE {
        return new FullContainerIterator<HandlersList>(&handlers_);
    }
 
    void register_handler(
        const EventRegistryEntry &entry, unsigned mask) OVERRIDE
    {
        AtomicHolder h(this);
        handlers_.push_front(entry);
        set_dirty();
    }
    void unregister_handler(EventHandler *handler, uint32_t user_arg = 0,
        uint32_t user_arg_mask = 0) OVERRIDE
    {
        AtomicHolder h(this);
        handlers_.remove_if([handler, user_arg, user_arg_mask](
                                const EventRegistryEntry &e) {
            return e.handler == handler &&
                ((e.user_arg & user_arg_mask) == (user_arg & user_arg_mask));
        });
        set_dirty();
    }
 
 private:
  typedef std::forward_list<EventRegistryEntry> HandlersList;
  HandlersList handlers_;
};
 
class TreeEventHandlers : public EventRegistry, private Atomic {
public:
    TreeEventHandlers();
 
    EventIterator* create_iterator() OVERRIDE;
    void register_handler(const EventRegistryEntry &entry,
                          unsigned mask) OVERRIDE;
    void unregister_handler(EventHandler *handler, uint32_t user_arg = 0,
        uint32_t user_arg_mask = 0) OVERRIDE;
    void reserve(size_t count) OVERRIDE;
 
private:
    class Iterator;
    friend class Iterator;
 
    struct cmpop
    {
        bool operator()(const EventRegistryEntry &d, uint64_t k)
        {
            return d.event < k;
        }
        bool operator()(uint64_t k, const EventRegistryEntry &d)
        {
            return k < d.event;
        }
        bool operator()(const EventRegistryEntry &a, const EventRegistryEntry &b)
        {
            return a.event < b.event;
        }
    };
 
    typedef SortedListSet<EventRegistryEntry, cmpop> OneMaskMap;
    typedef std::map<uint8_t, OneMaskMap> MaskLookupMap;
    MaskLookupMap handlers_;
};
 
}; /* namespace openlcb */
 
#endif  // _OPENLCB_EVENTHANDLERCONTAINER_HXX_