patterns.cppm

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
module;
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
export module kcenon.common:patterns;
 
export namespace kcenon::common::patterns {
 
// ============================================================================
// Event Bus
// ============================================================================
 
class SimpleEventBus {
public:
    SimpleEventBus() : running_(false), next_id_(1) {}
 
    ~SimpleEventBus() {
        stop();
    }
 
    void start() {
        running_.store(true, std::memory_order_release);
    }
 
    void stop() {
        running_.store(false, std::memory_order_release);
    }
 
    bool is_running() const {
        return running_.load(std::memory_order_acquire);
    }
 
    template<typename Event>
    uint64_t subscribe(std::function<void(const Event&)> handler) {
        std::unique_lock lock(mutex_);
        uint64_t id = next_id_++;
        auto type = std::type_index(typeid(Event));
 
        auto& handlers = handlers_[type];
        handlers.push_back({id, [handler](const void* event) {
            handler(*static_cast<const Event*>(event));
        }});
 
        return id;
    }
 
    void unsubscribe(uint64_t subscription_id) {
        std::unique_lock lock(mutex_);
        for (auto& [type, handlers] : handlers_) {
            handlers.erase(
                std::remove_if(handlers.begin(), handlers.end(),
                    [subscription_id](const auto& entry) {
                        return entry.id == subscription_id;
                    }),
                handlers.end());
        }
    }
 
    template<typename Event>
    void publish(const Event& event) {
        if (!is_running()) return;
 
        std::shared_lock lock(mutex_);
        auto type = std::type_index(typeid(Event));
        auto it = handlers_.find(type);
        if (it != handlers_.end()) {
            for (const auto& entry : it->second) {
                entry.handler(&event);
            }
        }
    }
 
    template<typename Event>
    size_t subscriber_count() const {
        std::shared_lock lock(mutex_);
        auto type = std::type_index(typeid(Event));
        auto it = handlers_.find(type);
        if (it != handlers_.end()) {
            return it->second.size();
        }
        return 0;
    }
 
    void clear() {
        std::unique_lock lock(mutex_);
        handlers_.clear();
    }
 
private:
    struct HandlerEntry {
        uint64_t id;
        std::function<void(const void*)> handler;
    };
 
    mutable std::shared_mutex mutex_;
    std::atomic<bool> running_;
    std::atomic<uint64_t> next_id_;
    std::unordered_map<std::type_index, std::vector<HandlerEntry>> handlers_;
};
 
// ============================================================================
// Result Helpers (re-exported from result partition)
// ============================================================================
 
// Note: Result<T> and related types are in the :result partition
// This partition focuses on design patterns like EventBus
 
} // namespace kcenon::common::patterns