delegate.hpp

#ifndef ENTT_SIGNAL_DELEGATE_HPP
#define ENTT_SIGNAL_DELEGATE_HPP


#include <tuple>
#include <cstring>
#include <utility>
#include <algorithm>
#include <functional>
#include <type_traits>
#include "../config/config.h"


namespace entt {


namespace internal {


template<typename Ret, typename... Args>
auto to_function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);


template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<Payload &, Type &>>>
auto to_function_pointer(Ret(*)(Type &, Args...), Payload &) -> Ret(*)(Args...);


template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...), const Class &) -> Ret(*)(Args...);


template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...) const, const Class &) -> Ret(*)(Args...);


template<typename Class, typename Type>
auto to_function_pointer(Type Class:: *, const Class &) -> Type(*)();


template<typename>
struct function_extent;


template<typename Ret, typename... Args>
struct function_extent<Ret(*)(Args...)> {
    static constexpr auto value = sizeof...(Args);
};


template<typename Func>
constexpr auto function_extent_v = function_extent<Func>::value;


}


template<auto>
struct connect_arg_t {};


template<auto Func>
constexpr connect_arg_t<Func> connect_arg{};


template<typename>
class delegate;


template<typename Ret, typename... Args>
class delegate<Ret(Args...)> {
    using proto_fn_type = Ret(const void *, std::tuple<Args &&...>);

    template<auto Function, std::size_t... Index>
    void connect(std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Function), std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = nullptr;

        fn = [](const void *, std::tuple<Args &&...> args) -> Ret {
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Function, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }

    template<auto Candidate, typename Type, std::size_t... Index>
    void connect(Type &value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type &, std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = &value_or_instance;

        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
            Type *curr = nullptr;

            if constexpr(std::is_const_v<Type>) {
                curr = static_cast<Type *>(payload);
            } else {
                curr = static_cast<Type *>(const_cast<void *>(payload));
            }

            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Candidate, *curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }

public:
    using function_type = Ret(Args...);

    delegate() ENTT_NOEXCEPT
        : fn{nullptr}, data{nullptr}
    {}

    template<auto Function>
    delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Function>();
    }

    template<auto Candidate, typename Type>
    delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Candidate>(value_or_instance);
    }

    template<auto Function>
    void connect() ENTT_NOEXCEPT {
        constexpr auto extent = internal::function_extent_v<decltype(internal::to_function_pointer(std::declval<decltype(Function)>()))>;
        connect<Function>(std::make_index_sequence<extent>{});
    }

    template<auto Candidate, typename Type>
    void connect(Type &value_or_instance) ENTT_NOEXCEPT {
        constexpr auto extent = internal::function_extent_v<decltype(internal::to_function_pointer(std::declval<decltype(Candidate)>(), value_or_instance))>;
        connect<Candidate>(value_or_instance, std::make_index_sequence<extent>{});
    }

    void reset() ENTT_NOEXCEPT {
        fn = nullptr;
        data = nullptr;
    }

    const void * instance() const ENTT_NOEXCEPT {
        return data;
    }

    Ret operator()(Args... args) const {
        ENTT_ASSERT(fn);
        return fn(data, std::forward_as_tuple(std::forward<Args>(args)...));
    }

    explicit operator bool() const ENTT_NOEXCEPT {
        // no need to test also data
        return fn;
    }

    bool operator==(const delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
        return fn == other.fn && data == other.data;
    }

private:
    proto_fn_type *fn;
    const void *data;
};


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


template<auto Function>
delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Function))>>;


template<auto Candidate, typename Type>
delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Candidate, value_or_instance))>>;


}


#endif // ENTT_SIGNAL_DELEGATE_HPP