Signals.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <type_traits>
#include <vector>
 
namespace volcart
{
 
template <class... Types>
class Signal
{
public:
    using SlotFnType = std::function<void(Types...)>;
 
    void connect(SlotFnType slot)
    {
        connections_.emplace_back(std::move(slot));
    }
 
    template <class Obj, class ObjMemberFn>
    void connect(Obj* obj, ObjMemberFn&& fn)
    {
        connections_.emplace_back(
            [=](Types... args) { return (*obj.*fn)(args...); });
    }
 
    template <class Obj, class Ret>
    void connect(Obj* obj, Ret (Obj::*fn)())
    {
        connections_.emplace_back(
            [=](Types... /*unused*/) { return (*obj.*fn)(); });
    }
 
    template <class Obj, class Ret>
    void connect(const Obj* obj, Ret (Obj::*fn)() const)
    {
        connections_.emplace_back(
            [=](Types... /*unused*/) { return (*obj.*fn)(); });
    }
 
    template <
        class Enabled = typename std::enable_if<
            std::is_empty<std::tuple<Types...>(Types...)>::value,
            bool>>
    void connect(const std::function<void()>& slot)
    {
        connections_.emplace_back([=](Types&&... /*unused*/) { slot(); });
    }
 
    void disconnect() { connections_.clear(); }
 
    std::size_t numConnections() const { return connections_.size(); }
 
    void send(Types... args) const
    {
        for (const auto& c : connections_) {
            c.slot(args...);
        }
    }
 
    void operator()(Types... args) const { send(std::forward<Types>(args)...); }
 
private:
    struct Connection {
        Connection(const SlotFnType& f) { slot = f; }
        SlotFnType slot;
    };
    std::vector<Connection> connections_;
};
 
template <>
template <class Obj, class ObjMemberFn>
void Signal<>::connect(Obj* obj, ObjMemberFn&& fn)
{
    connections_.emplace_back([=]() { return (*obj.*fn)(); });
}
 
template <>
inline void Signal<>::operator()() const
{
    send();
}
 
}  // namespace volcart