apply.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_APPLY_HPP__
#define NEFORCE_CORE_FUNCTIONAL_APPLY_HPP__

 
#include "NeForce/core/functional/invoke.hpp"
#include "NeForce/core/utility/tuple.hpp"
NEFORCE_BEGIN_NAMESPACE__

NEFORCE_BEGIN_INNER__
 
template <template <typename...> class, typename, typename>
struct __apply_unpack_tuple : false_type {};
 
template <template <typename...> class Trait, typename T, typename... U>
struct __apply_unpack_tuple<Trait, T, tuple<U...>> : bool_constant<Trait<T, U...>::value> {};
 
template <template <typename...> class Trait, typename T, typename... U>
struct __apply_unpack_tuple<Trait, T, tuple<U...>&> : bool_constant<Trait<T, U&...>::value> {};
 
template <template <typename...> class Trait, typename T, typename... U>
struct __apply_unpack_tuple<Trait, T, const tuple<U...>> : bool_constant<Trait<T, const U...>::value> {};
 
template <template <typename...> class Trait, typename T, typename... U>
struct __apply_unpack_tuple<Trait, T, const tuple<U...>&> : bool_constant<Trait<T, const U&...>::value> {};
 
 
template <typename F, typename Tuple, size_t... Idx>
constexpr auto __apply_impl(F&& f, Tuple&& t, _NEFORCE index_sequence<Idx...>) {
    return _NEFORCE invoke(_NEFORCE forward<F>(f),
                           _NEFORCE forward<decltype(_NEFORCE get<Idx>(_NEFORCE forward<Tuple>(t)))>(
                                   _NEFORCE get<Idx>(_NEFORCE forward<Tuple>(t)))...);
}
 
NEFORCE_END_INNER__


template <typename Func, typename Tuple>
constexpr decltype(auto)
apply(Func&& f, Tuple&& t) noexcept(inner::__apply_unpack_tuple<_NEFORCE is_nothrow_invocable, Func, Tuple>::value) {
    using Indices = make_index_sequence<tuple_size<remove_reference_t<Tuple>>::value>;
    return inner::__apply_impl(_NEFORCE forward<Func>(f), _NEFORCE forward<Tuple>(t), Indices{});
}
 // Tuple
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_APPLY_HPP__