EventRouter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <utility>
#include <variant>
 
#include "corium/internal/FastDelegate.hpp"
 
namespace corium {
 
template <
    typename EventVariant,
    size_t MaxSubscribersPerTopic = 8,
    size_t MaxTopics = 8
>
class EventRouter {
public:
    using DelegateType = internal::EventHandlerDelegate<EventVariant, 32>;
 
    constexpr EventRouter() noexcept = default;
 
    bool subscribe(uint32_t topicId, DelegateType subscriber) noexcept {
        // Find existing topic slot
        for (size_t i = 0; i < m_numTopics; ++i) {
            if (m_topics[i].topicId == topicId) {
                if (m_topics[i].subscriberCount >= MaxSubscribersPerTopic) {
                    return false; // Topic subscriber capacity reached
                }
                m_topics[i].subscribers[m_topics[i].subscriberCount++] = std::move(subscriber);
                return true;
            }
        }
 
        // Allocate new topic slot
        if (m_numTopics >= MaxTopics) {
            return false; // Max topics reached
        }
 
        auto& newTopic = m_topics[m_numTopics++];
        newTopic.topicId = topicId;
        newTopic.subscriberCount = 1;
        newTopic.subscribers[0] = std::move(subscriber);
        return true;
    }
 
    template <typename Event, typename Callable>
    bool subscribeEvent(uint32_t topicId, Callable callable) noexcept {
        return subscribe(topicId, DelegateType([c = std::move(callable)](const EventVariant& var) {
            if (std::holds_alternative<Event>(var)) {
                c(std::get<Event>(var));
            }
        }));
    }
 
    [[nodiscard]] size_t publish(uint32_t topicId, const EventVariant& event) const noexcept {
        for (size_t i = 0; i < m_numTopics; ++i) {
            if (m_topics[i].topicId == topicId) {
                for (size_t j = 0; j < m_topics[i].subscriberCount; ++j) {
                    m_topics[i].subscribers[j](event);
                }
                return m_topics[i].subscriberCount;
            }
        }
        return 0;
    }
 
    template <typename Event>
    [[nodiscard]] size_t publishEvent(uint32_t topicId, const Event& event) const noexcept {
        return publish(topicId, EventVariant{event});
    }
 
    void clear() noexcept {
        m_numTopics = 0;
        for (auto& topic : m_topics) {
            topic.subscriberCount = 0;
        }
    }
 
    [[nodiscard]] size_t topicCount() const noexcept {
        return m_numTopics;
    }
 
private:
    struct TopicSlot {
        uint32_t topicId{0};
        size_t subscriberCount{0};
        std::array<DelegateType, MaxSubscribersPerTopic> subscribers{};
    };
 
    std::array<TopicSlot, MaxTopics> m_topics{};
    size_t m_numTopics{0};
};
 
} // namespace corium