traits.h

Go to the documentation of this file.

 
#ifndef GUL14_TRAITS_H_
#define GUL14_TRAITS_H_
 
#include <functional> // for std::invoke on C++17 compilers
#include <type_traits>
#include <utility>
 
#include "gul14/internal.h"
 
namespace gul14 {
 
template <typename T, typename = int>
struct IsContainerLike : std::false_type { };
 
template <typename T>
struct IsContainerLike <T,
    typename std::enable_if_t<true,
        decltype(std::declval<T>().cbegin(),
            std::declval<T>().cend(),
            std::declval<typename T::value_type>(),
            0)
    >>
    : std::true_type { };
 
template <typename T>
using remove_cvref = typename std::remove_cv<std::remove_reference_t<T>>;
 
template <typename T>
using remove_cvref_t = typename remove_cvref<T>::type;
 
template <typename...>
using void_t = void;
 
 
//
// invoke & friends
//
#if __cplusplus >= 201703L
 
using std::invoke;
using std::invoke_result;
using std::invoke_result_t;
using std::is_invocable;
using std::is_invocable_r;
 
#else
 
namespace detail_invoke {
 
#define GUL14_INVOKE_RETURN(...) \
  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
 
template <typename T>
struct is_reference_wrapper : std::false_type {};
 
template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>>
    : std::true_type {};
 
template <bool, int>
struct Invoke;
 
template <>
struct Invoke<true /* pmf */, 0 /* is_base_of */> {
    template <typename R, typename T, typename Arg, typename... Args>
    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
    GUL14_INVOKE_RETURN((std::forward<Arg>(arg).*pmf)(std::forward<Args>(args)...))
};
 
template <>
struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
    template <typename R, typename T, typename Arg, typename... Args>
    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
    GUL14_INVOKE_RETURN((std::forward<Arg>(arg).get().*pmf)(std::forward<Args>(args)...))
};
 
template <>
struct Invoke<true /* pmf */, 2 /* otherwise */> {
    template <typename R, typename T, typename Arg, typename... Args>
    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
    GUL14_INVOKE_RETURN(((*std::forward<Arg>(arg)).*pmf)(std::forward<Args>(args)...))
};
 
template <>
struct Invoke<false /* pmo */, 0 /* is_base_of */> {
    template <typename R, typename T, typename Arg>
    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
    GUL14_INVOKE_RETURN(std::forward<Arg>(arg).*pmo)
};
 
template <>
struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
    template <typename R, typename T, typename Arg>
    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
    GUL14_INVOKE_RETURN(std::forward<Arg>(arg).get().*pmo)
};
 
template <>
struct Invoke<false /* pmo */, 2 /* otherwise */> {
    template <typename R, typename T, typename Arg>
    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
        GUL14_INVOKE_RETURN((*std::forward<Arg>(arg)).*pmo)
};
 
template <typename R, typename T, typename Arg, typename... Args>
inline constexpr auto invoke(R T::*f, Arg&& arg, Args&&... args)
    GUL14_INVOKE_RETURN(
        Invoke<std::is_function<R>::value,
                (std::is_base_of<T, std::decay_t<Arg>>::value
                    ? 0
                    : is_reference_wrapper<std::decay_t<Arg>>::value
                        ? 1
                        : 2)>::invoke(f, std::forward<Arg>(arg),
                                      std::forward<Args>(args)...))
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4100)
#endif
template <typename F, typename... Args>
inline constexpr auto invoke(F &&f, Args &&... args)
    GUL14_INVOKE_RETURN(std::forward<F>(f)(std::forward<Args>(args)...))
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#undef GUL14_INVOKE_RETURN
 
} // namespace detail_invoke
 
template <typename F, typename... Args>
inline constexpr auto
invoke(F&& f, Args&&... args) noexcept(
    noexcept(detail_invoke::invoke(std::forward<F>(f), std::forward<Args>(args)...)))
    -> decltype(detail_invoke::invoke(std::forward<F>(f), std::forward<Args>(args)...))
{
    return detail_invoke::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}
 
 
namespace detail_invoke_result {
 
template <typename T>
struct identity { using type = T; };
 
template <typename Void, typename, typename...>
struct invoke_result {};
 
template <typename F, typename... Args>
struct invoke_result<void_t<decltype(invoke(
                            std::declval<F>(), std::declval<Args>()...))>,
                        F,
                        Args...>
    : identity<decltype(
            invoke(std::declval<F>(), std::declval<Args>()...))> {};
 
} // namespace detail_invoke_result
 
template <typename F, typename... Args>
using invoke_result = detail_invoke_result::invoke_result<void, F, Args...>;
 
template <typename F, typename... Args>
using invoke_result_t = typename invoke_result<F, Args...>::type;
 
 
namespace detail_invocable {
 
template <typename Void, typename, typename...>
struct is_invocable : std::false_type {};
 
template <typename F, typename... Args>
struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
    : std::true_type {};
 
template <typename Void, typename, typename, typename...>
struct is_invocable_r : std::false_type {};
 
template <typename R, typename F, typename... Args>
struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
                        R,
                        F,
                        Args...>
    : std::is_convertible<invoke_result_t<F, Args...>, R> {};
 
} // namespace detail_invocable
 
template <typename F, typename... Args>
using is_invocable = detail_invocable::is_invocable<void, F, Args...>;
 
template <typename R, typename F, typename... Args>
using is_invocable_r = detail_invocable::is_invocable_r<void, R, F, Args...>;
 
#endif // __cplusplus < 201703L
 
 
} // namespace gul14
 
#endif
 
// vi:ts=4:sw=4:sts=4:et