Signal.h

Go to the documentation of this file.

 
#pragma once
 
#include "detail/SignalInternal.h"
 
#include "ncutility/NcError.h"
 
#include <algorithm>
 
namespace nc
{
class Connection
{
    public:
        explicit Connection(std::weak_ptr<detail::SharedConnectionState> state) noexcept
            : m_state{std::move(state)}
        {
        }
 
        ~Connection() noexcept
        {
            Disconnect();
        }
 
        Connection(Connection&&) = default;
        Connection& operator=(Connection&&) = default;
        Connection(const Connection&) = delete;
        Connection& operator=(const Connection&) = delete;
 
        bool IsConnected() const noexcept
        {
            const auto state = m_state.lock();
            return state && state->IsConnected();
        }
 
        bool Disconnect() noexcept
        {
            auto state = m_state.lock();
            return state && state->Disconnect();
        }
 
    private:
        std::weak_ptr<detail::SharedConnectionState> m_state;
};
 
struct SignalPriority
{
    static constexpr size_t Lowest = 0ull;
    static constexpr size_t Highest = std::numeric_limits<size_t>::max();
};
 
template<class... Args>
class Signal
{
    public:
        using Slot_t = detail::Slot<Args...>;
 
        Signal() = default;
        Signal(Signal&&) = default;
        Signal& operator=(Signal&&) = default;
        Signal(const Signal&) = delete;
        Signal& operator=(const Signal&) = delete;
 
        [[nodiscard]] auto Connect(std::move_only_function<void(Args...)> func, size_t priority = SignalPriority::Highest) -> Connection
        {
            const auto pos = std::ranges::find_if(m_slots, [priority](auto&& slot)
            {
                return priority >= slot.Priority();
            });
 
            if (pos != m_slots.cend())
            {
                auto result = m_slots.emplace(pos, std::move(func), m_link.get(), priority, ++m_currentId);
                return Connection{result->GetState()};
            }
 
            auto& result = m_slots.emplace_back(std::move(func), m_link.get(), priority, ++m_currentId);
            return Connection{result.GetState()};
        }
 
        template<class T>
        [[nodiscard]] auto Connect(T *inst, void (T::*func)(Args...), size_t priority = SignalPriority::Highest) -> Connection
        {
            return Connect([=](Args... args){ (inst->*func)(args...); }, priority);
        }
 
        template<class T>
        [[nodiscard]] auto Connect(const T *inst, void (T::*func)(Args...) const, size_t priority = SignalPriority::Highest) -> Connection
        {
            return Connect([=](Args... args){ (inst->*func)(args...); }, priority);
        }
 
        void DisconnectAll()
        {
            m_slots.clear();
            m_currentId = 0;
            m_link->GetPendingDisconnections(); // Don't need Sync() - just discard
        }
 
        auto ConnectionCount() const noexcept -> size_t
        {
            Sync();
            return m_slots.size();
        }
 
        void Emit(Args... args)
        {
            Sync();
            for (auto& slot : m_slots)
            {
                slot(args...);
            }
        }
 
        void operator()(Args... args)
        {
            Emit(args...);
        }
 
    private:
        mutable std::unique_ptr<detail::ConnectionBacklink> m_link = std::make_unique<detail::ConnectionBacklink>();
        mutable std::vector<Slot_t> m_slots{};
        int m_currentId{0};
 
        void Sync() const
        {
            const auto pendingRemovals = m_link->GetPendingDisconnections();
            for(const auto id : pendingRemovals)
            {
                std::erase_if(m_slots, [id](const auto& state) { return state.Id() == id; });
            }
        }
};
} // namespace nc