bus.h

#pragma once
 
#include <cstdint>
#include <algorithm>
#include <functional>
#include <utility>
#include <vector>
 
namespace Vkm::Engine {

using ListenerId = uint32_t;

class IBus {
    public:
        IBus() = default;
        virtual ~IBus() = default;
 
        IBus(const IBus& other) = delete;
        IBus& operator=(const IBus& other) = delete;
 
        IBus(IBus && other) = delete;
        IBus& operator=(IBus && other) = delete;
 
    public:
        virtual void takeQueue() = 0;

        virtual void deliver() = 0;

        virtual bool hasListeners() const = 0;
};

template<typename EventT>
class Bus : public IBus {
    public:
        Bus() = default;
        ~Bus() override = default;
 
        Bus(const Bus& other) = delete;
        Bus& operator=(const Bus& other) = delete;
 
        Bus(Bus && other) = delete;
        Bus& operator=(Bus && other) = delete;
 
    public:
        ListenerId subscribe(std::function<void(const EventT&)> cb) {
            const ListenerId id = m_nextId++;
 
            if (m_flushDepth > 0) m_pending.push_back({id, std::move(cb)});
            else                  m_listeners.push_back({id, std::move(cb)});
            return id;
        }

        bool remove(ListenerId id) {
            for (auto it = m_listeners.begin(); it != m_listeners.end(); ++it) {
                if (it->id != id) continue;
 
                if (m_flushDepth != 0) it->alive = false;
                else                   m_listeners.erase(it);
                return true;
            }
            for (auto it = m_pending.begin(); it != m_pending.end(); ++it) {
                if (it->id != id) continue;
 
                m_pending.erase(it);
                return true;
            }
            return false;
        }

        void emit(const EventT& event) {
            DispatchScope scope(*this);
            const size_t n = m_listeners.size();
            for (size_t i = 0; i < n; ++i) {
                if (m_listeners[i].alive) m_listeners[i].cb(event);
            }
        }

        void enqueue(EventT event) {
            m_queue.push_back(std::move(event));
        }

        void takeQueue() override {
            m_dispatch.clear();
            m_dispatch.swap(m_queue);
        }

        void deliver() override {
            if (m_dispatch.empty()) return;
 
            DispatchScope scope(*this);
            const size_t n = m_listeners.size();
            for (auto& e : m_dispatch) {
                for (size_t i = 0; i < n; ++i) {
                    if (m_listeners[i].alive) m_listeners[i].cb(e);
                }
            }
        }

        bool hasListeners() const override {
            for (const Entry& e : m_listeners) {
                if (e.alive) return true;
            }
            return !m_pending.empty();
        }
 
    private:
        struct Entry {
            ListenerId id;
            std::function<void(const EventT&)> cb;
            bool alive = true;  
        };

        class DispatchScope {
            public:
                explicit DispatchScope(Bus& bus) : m_bus(bus) { ++m_bus.m_flushDepth; }
                ~DispatchScope() {
                    --m_bus.m_flushDepth;
                    m_bus.admitPending();
                }
 
                DispatchScope(const DispatchScope& other) = delete;
                DispatchScope& operator=(const DispatchScope& other) = delete;
 
                DispatchScope(DispatchScope && other) = delete;
                DispatchScope& operator=(DispatchScope && other) = delete;
 
            private:
                Bus& m_bus;
        };

        void admitPending() {
            if (m_flushDepth != 0) return;
 
            const auto dead = [](const Entry& e) { return !e.alive; };
            m_listeners.erase(
                std::remove_if(m_listeners.begin(), m_listeners.end(), dead),
                m_listeners.end()
            );
 
            if (m_pending.empty()) return;
            for (Entry& entry : m_pending) m_listeners.push_back(std::move(entry));
            m_pending.clear();
        }
 
    private:
        std::vector<Entry>  m_listeners;   
        std::vector<Entry>  m_pending;     
        std::vector<EventT> m_queue;       
        std::vector<EventT> m_dispatch;    
        ListenerId m_nextId     = 1;
        int        m_flushDepth = 0;       
};
 
} // namespace Vkm::Engine