delegate.hpp

#ifndef ENTT_SIGNAL_DELEGATE_HPP
#define ENTT_SIGNAL_DELEGATE_HPP


#include <utility>
#include "../config/config.h"


namespace entt {


template<typename>
class Delegate;


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

    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() ENTT_NOEXCEPT
        : stub{}
    {}

    bool empty() const ENTT_NOEXCEPT {
        // no need to test also stub.first
        return !stub.second;
    }

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

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

    void reset() ENTT_NOEXCEPT {
        stub.second = nullptr;
    }

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

    bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_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) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}


}


#endif // ENTT_SIGNAL_DELEGATE_HPP