event_bus.h

#pragma once
 
#include <cstddef>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
#include "core/memory/type_registry.h"
#include "core/memory/types.h"
#include "core/event/bus.h"
 
namespace Vkm::Engine {

class EventBus {
    public:
        EventBus() = default;
        ~EventBus() = default;
 
        EventBus(const EventBus& other) = delete;
        EventBus& operator=(const EventBus& other) = delete;
 
        EventBus(EventBus && other) = delete;
        EventBus& operator=(EventBus && other) = delete;
 
    public:
        template<typename EventT>
        ListenerId subscribe(std::function<void(const EventT&)> callback) {
            return bus<EventT>().subscribe(std::move(callback));
        }

        template<typename EventT>
        bool unsubscribe(ListenerId id) {
            auto* b = findBus<EventT>();
            return b ? b->remove(id) : false;
        }

        template<typename EventT>
        void emit(const EventT& event) {
            if (auto* b = findBus<EventT>()) b->emit(event);
        }

        template<typename EventT>
        void enqueue(EventT event) {
            bus<EventT>().enqueue(std::move(event));
        }

        void flush();

        void dropIdleBuses();

        std::size_t busCount() const { return m_buses.count(); }
 
    private:
        template<typename EventT>
        Bus<EventT>& bus() {
            IBus& base = m_buses.ensure<EventT>([] { return std::make_unique<Bus<EventT>>(); });
            return static_cast<Bus<EventT>&>(base);
        }

        template<typename EventT>
        Bus<EventT>* findBus() {
            return static_cast<Bus<EventT>*>(m_buses.find<EventT>());
        }
 
    private:
        TypeRegistry<IBus> m_buses;
 
        std::vector<IBus*> m_active;  
 
        bool m_flushing = false;
};

class EventSender {
    public:
        explicit EventSender(EventBus& bus) : m_bus(&bus) {}
        ~EventSender() = default;
 
        EventSender(const EventSender& other) = default;
        EventSender& operator=(const EventSender& other) = default;
 
        EventSender(EventSender && other) = default;
        EventSender& operator=(EventSender && other) = default;

        template<typename EventT>
        void emit(const EventT& event) { m_bus->emit(event); }

        template<typename EventT>
        void enqueue(EventT event) { m_bus->enqueue(std::move(event)); }
 
    private:
        EventBus* m_bus;
};
 
} // namespace Vkm::Engine