eventmap.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <unordered_map>
#include <functional>
#include <iostream>
#include <memory>
#include "../_Core/logger.h"
 
// maps event (practically ints) to functions
namespace Saga {
    class ICallback {
        public:
            virtual ~ICallback() = default;
    };
 
    template <typename ...DataType>
    class Callback : public ICallback {
    public:
        Callback(std::shared_ptr<std::function<void(DataType...)>> func) : func(func) {}
 
        void evoke(DataType... args) { (*func)(args...); }
 
    private:
        std::shared_ptr<std::function<void(DataType...)>> func;
    };
 
    class EventMap {
    public: 
        enum Id: uint64_t {};
    private:
        using Map = std::unordered_map<int, std::unordered_map<Id, std::shared_ptr<ICallback>>>;
    public:
        typedef typename Map::iterator iterator;
        typedef typename Map::const_iterator const_iterator;
        typedef typename Map::value_type value_type;
 
        const_iterator begin() const { return map.begin(); }
        const_iterator end() const { return map.end(); }
        iterator begin() { return map.begin(); }
        iterator end() { return map.end(); }
 
        template <typename Event>
        iterator find(Event event) { return map.find((int) event); }
 
        template <typename Event>
        const_iterator find(Event event) const { return map.find((int) event); }
 
        template <typename Event, typename ...DataType>
        Id addListener(Event event, std::shared_ptr<std::function<void(DataType...)>> callbackFunc) {
            const Id id = Id(++id_value());
 
            map[(int) event][id] = std::make_shared<Callback<DataType...>>(callbackFunc);
            return id;
        }
 
        template <typename Event>
        void removeListener(Event event, Id id) {
            if (map.count((int) event)) {
                int removeCnt = map[(int) event].erase(id);
                if (!removeCnt) SWARN("Trying to remove listener %d from event %d, but the event does not have this listener.", id, event);
            } else 
                SWARN("Trying to remove a listener from event %d, but the event does not exist.", event);
        }
 
        template <typename Event, typename ...DataType>
        void invoke(Event event, DataType... args) {
            if (map.count((int) event))
                for (auto& pp : map[(int) event])
                    std::dynamic_pointer_cast<Callback<DataType...>>(pp.second)->evoke(args...);
        }
 
    private:
        Map map;
        static auto id_value()
            -> uint64_t & {
            static uint64_t the_id;
            return the_id;
        }
    };
}