QEventBus.hpp

Go to the documentation of this file.

#pragma once
#include <EASTL/functional.h>
#include <EASTL/unordered_map.h>
#include <EASTL/vector.h>
#include <EASTL/queue.h>
#include <EASTL/unique_ptr.h>
#include <typeindex>
#include <mutex>
#include "IEvent.hpp"

 
namespace mce {

    struct SubscriptionToken {
        eastl::function<void()> unsubscribe;

        ~SubscriptionToken() { if (unsubscribe)unsubscribe(); }
    };

    class QEventBus {
    public:
        QEventBus(const std::string_view& eventNamespace);

        template<typename EventType>
        using Handler = eastl::function<void(const EventType&)>;

        template<typename EventType>
        SubscriptionToken subscribeRAII(Handler<EventType> handler);

        template<typename EventType>
        void subscribe(Handler<EventType> handler);

        template<typename EventType>
        void post(EventType&& event);

        void process();

        void runAsync();

        void stop();
 
        size_t getQueueSize() const;
        ~QEventBus();
 
        const std::string_view& getNamespace() const;
    private:
        void dispatch(const IEvent& e);
 
        
        struct TypeIndexHash {
            size_t operator()(const std::type_index& t) const noexcept {
                return t.hash_code();
            }
        };
 
        struct TypeIndexEqual {
            bool operator()(const std::type_index& a, const std::type_index& b) const noexcept {
                return a == b;
            }
        };
        eastl::unordered_map<
            std::type_index,
            eastl::vector<eastl::function<void(const IEvent&)>>,
            TypeIndexHash,
            TypeIndexEqual
        > handlers;
        eastl::queue<eastl::unique_ptr<IEvent>> queue;

        std::mutex mutex;

        std::mutex queueMutex;

        std::condition_variable conditionalVariable;

        std::atomic_bool bIsRunning = false;

        std::thread thread;
 
        const std::string_view eventNamespace;
    };
    template<typename EventType>
    inline SubscriptionToken QEventBus::subscribeRAII(Handler<EventType> handler) {
        std::lock_guard<std::mutex> lock(QEventBus::mutex);
 
        auto& handlers = QEventBus::handlers[typeid(EventType)];
 
        handlers.emplace_back([handler](const IEvent& e) {
            handler(static_cast<const EventType&>(e));
            });
 
        auto it = eastl::prev(handlers.end());
        std::type_index typeIdx = std::type_index(typeid(EventType));
 
        return SubscriptionToken{ [this, typeIdx, it]() {
                std::lock_guard<std::mutex> lock(QEventBus::mutex);
                auto mapIt = QEventBus::handlers.find(typeIdx);
                if (mapIt != QEventBus::handlers.end()) {
                    auto& vec = mapIt->second;
                    
                    vec.erase(it);
 
                    if (vec.empty()) {
                        QEventBus::handlers.erase(mapIt);
                    }
                }
            }
        };
    }
 
    template<typename EventType>
    inline void QEventBus::subscribe(Handler<EventType> handler) {
        std::lock_guard<std::mutex> lock(QEventBus::mutex);
 
        // Simply store the handler � no token or RAII logic.
        auto& handlers = QEventBus::handlers[typeid(EventType)];
        handlers.emplace_back([handler](const IEvent& e) {
            handler(static_cast<const EventType&>(e));
            });
    }
 
    template<typename EventType>
    inline void QEventBus::post(EventType&& event) {
        // Create an owned copy / move of the event on the heap
        using Decayed = std::decay_t<EventType>;
        auto ptr = eastl::make_unique<Decayed>(eastl::forward<EventType>(event));
        {
            std::lock_guard<std::mutex> lock(QEventBus::queueMutex);
            QEventBus::queue.push(eastl::move(ptr));
        }
        QEventBus::conditionalVariable.notify_one();
    }
}