TrackableSignalMap.hpp

#pragma once
 
#include "feed/impl/TrackableSignal.hpp"
#include "util/Mutex.hpp"
 
#include <boost/signals2.hpp>
 
#include <concepts>
#include <cstddef>
#include <functional>
#include <memory>
#include <mutex>
#include <unordered_map>
 
namespace feed::impl {
 
template <typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};

template <Hashable Key, typename Session, typename... Args>
class TrackableSignalMap {
    using ConnectionPtr = Session*;
    using ConnectionSharedPtr = std::shared_ptr<Session>;
    using SignalType = TrackableSignal<Session, Args...>;
    using SignalPtr = std::shared_ptr<SignalType>;
    using SignalsMap = std::unordered_map<Key, SignalPtr>;
 
    util::Mutex<SignalsMap> signalsMap_;
 
public:
    bool
    connectTrackableSlot(
        ConnectionSharedPtr const& trackable,
        Key const& key,
        std::function<void(Args...)> slot
    )
    {
        auto map = signalsMap_.template lock<std::scoped_lock>();
        auto it = map->find(key);
        if (it == map->end()) {
            auto signal = std::make_shared<SignalType>();
            it = map->emplace(key, std::move(signal)).first;
        }
 
        return it->second->connectTrackableSlot(trackable, slot);
    }

    bool
    disconnect(ConnectionPtr trackablePtr, Key const& key)
    {
        auto map = signalsMap_.template lock<std::scoped_lock>();
        auto const it = map->find(key);
        if (it == map->end())
            return false;
 
        auto const disconnected = it->second->disconnect(trackablePtr);
        // clean the map if there is no connection left.
        if (disconnected && it->second->count() == 0)
            map->erase(it);
 
        return disconnected;
    }

    void
    emit(Key const& key, Args const&... args)
    {
        auto const signal = [this, &key] -> SignalPtr {
            auto map = signalsMap_.template lock<std::scoped_lock>();
            auto const it = map->find(key);
            return it == map->end() ? nullptr : it->second;
        }();
 
        if (signal != nullptr)
            signal->emit(args...);
    }
};
}  // namespace feed::impl