Signal.h

#pragma once
 
#include "spark/patterns/details/Connection.h"
 
#include <functional>
#include <map>
 
#include <cstddef>
 
namespace spark::patterns
{
    template <typename... Args>
    class Signal final
    {
    public:
        explicit Signal();
        ~Signal();
 
        Signal(const Signal& signal) = delete;
        Signal(Signal&& signal) noexcept;
        Signal& operator=(const Signal& signal) = delete;
        Signal& operator=(Signal&& signal) noexcept;
 
        std::size_t connect(Slot<Args...>* slot);
 
        std::size_t connect(Slot<Args...>& slot);
 
        std::size_t connect(Slot<Args...>&& slot);
 
        std::size_t connect(const std::function<void(Args...)>& callback);
 
        std::size_t connect(std::function<void(Args...)>&& callback);
 
        void disconnect(std::size_t key);
 
        void disconnect(Slot<Args...>* slot);
 
        void disconnect(Slot<Args...>& slot);
 
        void clear();
 
        [[nodiscard]] bool isConnected(std::size_t key) const;
 
        [[nodiscard]] std::vector<std::size_t> connectedKeys() const;
 
        [[nodiscard]] std::vector<const Slot<Args...>*> connectedSlots() const;
 
        template <typename... FnArgs>
        void emit(FnArgs&&... args) const;
 
        void operator()(Args&&... args) const;
 
    private:
        std::size_t connect(Slot<Args...>* slot, bool managed);
 
        void move(Signal* signal);
 
    private:
        std::map<std::size_t, details::Connection<Args...>> m_connections;
        std::size_t m_sequence = 0;
    };
}
 
#include "spark/patterns/impl/Signal.h"