delegate.hpp

#ifndef ENTT_SIGNAL_DELEGATE_HPP
#define ENTT_SIGNAL_DELEGATE_HPP


#include <utility>


namespace entt {


template<typename>
class Delegate;


template<typename Ret, typename... Args>
class Delegate<Ret(Args...)> final {
    using proto_type = Ret(*)(void *, Args...);
    using stub_type = std::pair<void *, proto_type>;

    static Ret fallback(void *, Args...) noexcept { return {}; }

    template<Ret(*Function)(Args...)>
    static Ret proto(void *, Args... args) {
        return (Function)(args...);
    }

    template<typename Class, Ret(Class::*Member)(Args...)>
    static Ret proto(void *instance, Args... args) {
        return (static_cast<Class *>(instance)->*Member)(args...);
    }

public:
    Delegate() noexcept
        : stub{std::make_pair(nullptr, &fallback)}
    {}

    template<Ret(*Function)(Args...)>
    void connect() noexcept {
        stub = std::make_pair(nullptr, &proto<Function>);
    }

    template<typename Class, Ret(Class::*Member)(Args...)>
    void connect(Class *instance) noexcept {
        stub = std::make_pair(instance, &proto<Class, Member>);
    }

    void reset() noexcept {
        stub = std::make_pair(nullptr, &fallback);
    }

    Ret operator()(Args... args) {
        return stub.second(stub.first, args...);
    }

    bool operator==(const Delegate<Ret(Args...)> &other) const noexcept {
        return stub.first == other.stub.first && stub.second == other.stub.second;
    }

private:
    stub_type stub;
};


template<typename Ret, typename... Args>
bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) noexcept {
    return !(lhs == rhs);
}


}


#endif // ENTT_SIGNAL_DELEGATE_HPP