TrackableSignal.hpp

#pragma once
 
#include "util/Mutex.hpp"
 
#include <boost/signals2.hpp>
#include <boost/signals2/connection.hpp>
#include <boost/signals2/variadic_signal.hpp>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <mutex>
#include <unordered_map>
 
namespace feed::impl {

template <typename Session, typename... Args>
class TrackableSignal {
    using ConnectionPtr = Session*;
    using ConnectionSharedPtr = std::shared_ptr<Session>;
 
    // map of connection and signal connection, key is the pointer of the connection object
    // allow disconnect to be called in the destructor of the connection
    using ConnectionsMap = std::unordered_map<ConnectionPtr, boost::signals2::connection>;
    util::Mutex<ConnectionsMap> connections_;
 
    using SignalType = boost::signals2::signal<void(Args...)>;
    SignalType signal_;
 
public:
    bool
    connectTrackableSlot(ConnectionSharedPtr const& trackable, std::function<void(Args...)> slot)
    {
        auto connections = connections_.template lock<std::scoped_lock>();
        if (connections->contains(trackable.get())) {
            return false;
        }
 
        // This class can't hold the trackable's shared_ptr, because disconnect should be able to be
        // called in the the trackable's destructor. However, the trackable can not be destroyed
        // when the slot is being called either. `track_foreign` is racey when one shared_ptr is
        // tracked by multiple signals. Therefore we are storing a weak_ptr of the trackable and
        // using weak_ptr::lock() to atomically check existence and acquire a shared_ptr during slot
        // invocation. This guarantees to keep the trackable alive for the duration of the slot call
        // and avoids potential race conditions.
        connections->emplace(
            trackable.get(),
            signal_.connect([slot, weakTrackable = std::weak_ptr(trackable)](Args&&... args) {
                if (auto const lifeExtender = weakTrackable.lock(); lifeExtender)
                    std::invoke(slot, std::forward<Args...>(args)...);
            })
        );
        return true;
    }

    bool
    disconnect(ConnectionPtr trackablePtr)
    {
        if (auto connections = connections_.template lock<std::scoped_lock>();
            connections->contains(trackablePtr)) {
            connections->operator[](trackablePtr).disconnect();
            connections->erase(trackablePtr);
            return true;
        }
        return false;
    }

    void
    emit(Args const&... args) const
    {
        signal_(args...);
    }

    [[nodiscard]] std::size_t
    count() const
    {
        return connections_.template lock<std::scoped_lock>()->size();
    }
};
}  // namespace feed::impl