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 SignalsMap = std::unordered_map<Key, TrackableSignal<Session, Args...>>;
    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>();
        return map->operator[](key).connectTrackableSlot(trackable, slot);
    }

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

    void
    emit(Key const& key, Args const&... args)
    {
        auto map = signalsMap_.template lock<std::scoped_lock>();
        if (map->contains(key))
            map->operator[](key).emit(args...);
    }
};
}  // namespace feed::impl