invoke.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_INVOKE_HPP__
#define NEFORCE_CORE_FUNCTIONAL_INVOKE_HPP__

 
#include "NeForce/core/utility/reference_wrapper.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct invoke_memfun_ref_tag {
    constexpr invoke_memfun_ref_tag() noexcept = default;
};

struct invoke_memfun_deref_tag {
    constexpr invoke_memfun_deref_tag() noexcept = default;
};

struct invoke_memobj_ref_tag {
    constexpr invoke_memobj_ref_tag() noexcept = default;
};

struct invoke_memobj_deref_tag {
    constexpr invoke_memobj_deref_tag() noexcept = default;
};

struct invoke_other_tag {
    constexpr invoke_other_tag() noexcept = default;
};
 

template <typename T, typename Tag>
struct invoke_result_true {
    using invoke_type = Tag; 
    using type = T;          
};

struct invoke_result_false {};
 
 
NEFORCE_BEGIN_INNER__

template <typename MemPtr, typename Arg, typename... Args>
struct __invoke_result_memfun_ref {
private:
    template <typename F, typename T, typename... Args1>
    static invoke_result_true<decltype((_NEFORCE declval<T>().*_NEFORCE declval<F>())(_NEFORCE declval<Args1>()...)),
                              invoke_memfun_ref_tag>
    __test(int);
 
    template <typename...>
    static invoke_result_false __test(...);
 
public:
    using type = decltype(__test<MemPtr, Arg, Args...>(0));
};

template <typename MemPtr, typename Arg, typename... Args>
struct __invoke_result_memfun_deref {
private:
    template <typename F, typename T, typename... Args1>
    static invoke_result_true<decltype((*_NEFORCE declval<T>().*_NEFORCE declval<F>())(_NEFORCE declval<Args1>()...)),
                              invoke_memfun_deref_tag>
    __test(int);
 
    template <typename...>
    static invoke_result_false __test(...);
 
public:
    using type = decltype(__test<MemPtr, Arg, Args...>(0));
};

template <typename MemPtr, typename Arg>
struct __invoke_result_memobj_ref {
private:
    template <typename F, typename T>
    static invoke_result_true<decltype(_NEFORCE declval<T>().*_NEFORCE declval<F>()), invoke_memobj_ref_tag>
    __test(int);
 
    template <typename, typename>
    static invoke_result_false __test(...);
 
public:
    using type = decltype(__test<MemPtr, Arg>(0));
};

template <typename MemPtr, typename Arg>
struct __invoke_result_memobj_deref {
private:
    template <typename F, typename T>
    static invoke_result_true<decltype(*_NEFORCE declval<T>().*_NEFORCE declval<F>()), invoke_memobj_deref_tag>
    __test(int);
 
    template <typename, typename>
    static invoke_result_false __test(...);
 
public:
    using type = decltype(__test<MemPtr, Arg>(0));
};

template <typename MemPtr, typename Arg>
struct __invoke_result_memobj;

template <typename Res, typename Class, typename Arg>
struct __invoke_result_memobj<Res Class::*, Arg> {
    using Argval = remove_cvref_t<Arg>;
    using MemPtr = Res Class::*;
    using type = typename conditional_t<disjunction<is_same<Argval, Class>, is_base_of<Class, Argval>>::value,
                                        __invoke_result_memobj_ref<MemPtr, Arg>,
                                        __invoke_result_memobj_deref<MemPtr, Arg>>::type;
};

template <typename MemPtr, typename Arg, typename... Args>
struct __invoke_result_memfun;

template <typename Res, typename Class, typename Arg, typename... Args>
struct __invoke_result_memfun<Res Class::*, Arg, Args...> {
    using MemPtr = Res Class::*;
    using type = typename conditional_t<is_base_of<Class, remove_reference_t<Arg>>::value,
                                        __invoke_result_memfun_ref<MemPtr, Arg, Args...>,
                                        __invoke_result_memfun_deref<MemPtr, Arg, Args...>>::type;
};

template <bool IsMemObj, bool IsMemFun, typename F, typename... Args>
struct __invoke_result_dispatch {
    using type = invoke_result_false;
};

template <typename MemPtr, typename Arg>
struct __invoke_result_dispatch<true, false, MemPtr, Arg>
: __invoke_result_memobj<decay_t<MemPtr>, unwrap_reference_t<Arg>> {};

template <typename MemPtr, typename Arg, typename... Args>
struct __invoke_result_dispatch<false, true, MemPtr, Arg, Args...>
: __invoke_result_memfun<decay_t<MemPtr>, unwrap_reference_t<Arg>, Args...> {};

template <typename F, typename... Args>
struct __invoke_result_dispatch<false, false, F, Args...> {
private:
    template <typename F1, typename... Args1>
    static invoke_result_true<decltype(_NEFORCE declval<F1>()(_NEFORCE declval<Args1>()...)), invoke_other_tag>
    __test(int);
 
    template <typename...>
    static invoke_result_false __test(...);
 
public:
    using type = decltype(__test<F, Args...>(0));
};

template <typename F, typename... Args>
struct __invoke_result_aux
: __invoke_result_dispatch<is_member_object_pointer<remove_reference_t<F>>::value,
                           is_member_function_pointer<remove_reference_t<F>>::value, F, Args...>::type {};
 
NEFORCE_END_INNER__


template <typename Sign>
struct invoke_result;

template <typename F, typename... Args>
struct invoke_result<F(Args...)> : inner::__invoke_result_aux<F, Args...> {};

template <typename F, typename... Args>
using invoke_result_t = typename inner::__invoke_result_aux<F, Args...>::type;
 

NEFORCE_BEGIN_INNER__

template <typename Result, typename Ret, bool IsVoid = is_void<Ret>::value, typename Dummy = void>
struct __is_invocable_aux : false_type {};

template <typename Result, typename Ret>
struct __is_invocable_aux<Result, Ret, true, void_t<typename Result::type>> : true_type {};
 
#ifdef NEFORCE_COMPILER_GCC
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
#elif defined(NEFORCE_COMPILER_CLANG)
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wctor-dtor-privacy"
#elif defined(NEFORCE_COMPILER_MSVC)
#    pragma warning(push)
#    pragma warning(disable : 4624)
#endif

template <typename Result, typename Ret>
struct __is_invocable_aux<Result, Ret, false, void_t<typename Result::type>> {
private:
    using Res_t = typename Result::type;
 
    template <typename T, bool Nothrow = noexcept(_NEFORCE declvoid<T>(_NEFORCE declval<Res_t>())),
              typename = decltype(_NEFORCE declvoid<T>(_NEFORCE declval<Res_t>())),
              bool Dangle =
#if defined(NEFORCE_COMPILER_GCC) && defined(NEFORCE_PLATFORM_WINDOWS)
                      __reference_converts_from_temporary(T, Res_t)
#else
                      false
#endif
              >
    static bool_constant<Nothrow && !Dangle> __test(int);
 
    template <typename T, bool = false>
    static false_type __test(...);
 
public:
    using type = decltype(__test<Ret, true>(1));
};
 
#ifdef NEFORCE_COMPILER_CLANG
#    pragma clang diagnostic pop
#elif defined(NEFORCE_COMPILER_GCC)
#    pragma GCC diagnostic pop
#elif defined(NEFORCE_COMPILER_MSVC)
#    pragma warning(pop)
#endif
 
NEFORCE_END_INNER__
 

template <typename F, typename... Args>
struct is_invocable : inner::__is_invocable_aux<inner::__invoke_result_aux<F, Args...>, void>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename F, typename... Args>
NEFORCE_INLINE17 constexpr bool is_invocable_v = is_invocable<F, Args...>::value;
#endif
 

template <typename Ret, typename F, typename... Args>
struct is_invocable_r : inner::__is_invocable_aux<inner::__invoke_result_aux<F, Args...>, Ret>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Ret, typename F, typename... Args>
NEFORCE_INLINE17 constexpr bool is_invocable_r_v = is_invocable_r<Ret, F, Args...>::value;
#endif
 

NEFORCE_BEGIN_INNER__
 
template <typename F, typename T, typename... Args>
constexpr bool __invoke_is_nothrow_dispatch(invoke_memfun_ref_tag) {
    return noexcept((_NEFORCE declval<unwrap_reference_t<T>>().*_NEFORCE declval<F>())(_NEFORCE declval<Args>()...));
}
template <typename F, typename T, typename... Args>
constexpr bool __invoke_is_nothrow_dispatch(invoke_memfun_deref_tag) {
    return noexcept((*_NEFORCE declval<T>().*_NEFORCE declval<F>())(_NEFORCE declval<Args>()...));
}
template <typename F, typename T>
constexpr bool __invoke_is_nothrow_dispatch(invoke_memobj_ref_tag) {
    return noexcept(_NEFORCE declval<unwrap_reference_t<T>>().*_NEFORCE declval<F>());
}
template <typename F, typename T>
constexpr bool __invoke_is_nothrow_dispatch(invoke_memobj_deref_tag) {
    return noexcept(*_NEFORCE declval<T>().*_NEFORCE declval<F>());
}
template <typename F, typename... Args>
constexpr bool __invoke_is_nothrow_dispatch(invoke_other_tag) {
    return noexcept(_NEFORCE declval<F>()(_NEFORCE declval<Args>()...));
}

template <typename Result, typename F, typename... Args>
struct __invoke_is_nothrow : bool_constant<__invoke_is_nothrow_dispatch<F, Args...>(typename Result::invoke_type{})> {};

template <typename F, typename... Args>
using __bind_invoke_is_nothrow = __invoke_is_nothrow<__invoke_result_aux<F, Args...>, F, Args...>;
 
NEFORCE_END_INNER__
 

template <typename F, typename... Args>
struct is_nothrow_invocable : conjunction<is_invocable<F, Args...>, inner::__bind_invoke_is_nothrow<F, Args...>>::type {
};
 
#ifdef NEFORCE_STANDARD_14
template <typename F, typename... Args>
NEFORCE_INLINE17 constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<F, Args...>::value;
#endif
 

NEFORCE_BEGIN_INNER__
 
template <typename T, typename U = unwrap_reference_t<T>>
constexpr U&& __invoke_forward(remove_reference_t<T>& t) noexcept {
    return static_cast<U&&>(t);
}
 
template <typename Res, typename F, typename... Args>
NEFORCE_CONSTEXPR14 Res __invoke_dispatch(invoke_other_tag, F&& f, Args&&... args) {
    return _NEFORCE forward<F>(f)(_NEFORCE forward<Args>(args)...);
}
template <typename Res, typename MemFun, typename T, typename... Args>
NEFORCE_CONSTEXPR14 Res __invoke_dispatch(invoke_memfun_ref_tag, MemFun&& f, T&& t, Args&&... args) {
    return (inner::__invoke_forward<T>(t).*f)(_NEFORCE forward<Args>(args)...);
}
template <typename Res, typename MemFun, typename T, typename... Args>
NEFORCE_CONSTEXPR14 Res __invoke_dispatch(invoke_memfun_deref_tag, MemFun&& f, T&& t, Args&&... args) {
    return (*_NEFORCE forward<T>(t).*f)(_NEFORCE forward<Args>(args)...);
}
template <typename Res, typename MemPtr, typename T>
NEFORCE_CONSTEXPR14 Res __invoke_dispatch(invoke_memobj_ref_tag, MemPtr&& f, T&& t) {
    return inner::__invoke_forward<T>(t).*f;
}
template <typename Res, typename MemPtr, typename T>
NEFORCE_CONSTEXPR14 Res __invoke_dispatch(invoke_memobj_deref_tag, MemPtr&& f, T&& t) {
    return *_NEFORCE forward<T>(t).*f;
}
 
NEFORCE_END_INNER__
 

template <typename Callable, typename... Args>
NEFORCE_CONSTEXPR14 typename inner::__invoke_result_aux<Callable, Args...>::type
invoke(Callable&& f, Args&&... args) noexcept(is_nothrow_invocable<Callable, Args...>::value) {
    using result = inner::__invoke_result_aux<Callable, Args...>;
    using type = typename result::type;
    using tag = typename result::invoke_type;
    return inner::__invoke_dispatch<type>(tag{}, _NEFORCE forward<Callable>(f), _NEFORCE forward<Args>(args)...);
}
 

NEFORCE_BEGIN_INNER__
 
template <typename T, typename Tag, typename Res, typename Callable, typename... Args>
NEFORCE_CONSTEXPR14 enable_if_t<is_invocable_r<Res, Callable, Args...>::value && is_void<Res>::value, Res>
__invoke_r_dispatch(Callable&& f, Args&&... args) noexcept(is_nothrow_invocable<Callable, Args...>::value) {
    inner::__invoke_dispatch<T>(Tag{}, _NEFORCE forward<Callable>(f), _NEFORCE forward<Args>(args)...);
    return;
}
 
template <typename T, typename Tag, typename Res, typename Callable, typename... Args>
NEFORCE_CONSTEXPR14 enable_if_t<is_invocable_r<Res, Callable, Args...>::value && !is_void<Res>::value, Res>
__invoke_r_dispatch(Callable&& f, Args&&... args) noexcept(is_nothrow_invocable<Callable, Args...>::value) {
    return inner::__invoke_dispatch<T>(Tag{}, _NEFORCE forward<Callable>(f), _NEFORCE forward<Args>(args)...);
}
 
NEFORCE_END_INNER__
 

template <typename Res, typename Callable, typename... Args>
NEFORCE_CONSTEXPR14 enable_if_t<is_invocable_r<Res, Callable, Args...>::value, Res>
invoke_r(Callable&& f, Args&&... args) noexcept(is_nothrow_invocable<Callable, Args...>::value) {
    using result = inner::__invoke_result_aux<Callable, Args...>;
    using type = typename result::type;
    using tag = typename result::invoke_type;
    return inner::__invoke_r_dispatch<type, tag, Res, Callable, Args...>(_NEFORCE forward<Callable>(f),
                                                                         _NEFORCE forward<Args>(args)...);
}
 // InvokeFunction
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_INVOKE_HPP__