traits.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_TRAITS_HPP
#define JOIN_CORE_TRAITS_HPP
 
// C++.
#include <utility>
#include <type_traits>
#include <bits/enable_special_members.h>
 
namespace join
{
    struct in_place_t
    {
        explicit in_place_t () = default;
    };
 
    template <typename T>
    struct in_place_type_t
    {
        explicit in_place_type_t () = default;
    };
 
    template <std::size_t I>
    struct in_place_index_t
    {
        explicit in_place_index_t () = default;
    };
 
    template <typename T>
    struct identity
    {
        using type = T;
    };
 
    template <typename T>
    using identity_t = typename identity<T>::type;
 
    template <typename... Ts>
    struct overload;
 
    template <>
    struct overload<>
    {
        void operator() () const;
    };
 
    template <typename First, typename... Ts>
    struct overload<First, Ts...> : overload<Ts...>
    {
        using overload<Ts...>::operator();
 
        identity<First> operator() (First) const;
    };
 
    template <typename... Ts>
    struct overload<void, Ts...> : overload<Ts...>
    {
        using overload<Ts...>::operator();
 
        identity<void> operator() () const;
    };
 
    template <typename T, typename... Ts>
    using match_t = typename std::result_of_t<overload<Ts...> (T)>::type;
 
    template <typename T, typename... Ts>
    struct find_index : std::integral_constant<std::size_t, 0>
    {
    };
 
    template <typename T, typename First, typename... Ts>
    struct find_index<T, First, Ts...>
    : std::integral_constant<std::size_t, std::is_same<T, First>::value ? 0 : find_index<T, Ts...>::value + 1>
    {
    };
 
    template <std::size_t I, typename T, typename... Ts>
    struct find_element
    {
        using type = typename find_element<I - 1, Ts...>::type;
    };
 
    template <typename T, typename... Ts>
    struct find_element<0, T, Ts...>
    {
        using type = T;
    };
 
    template <std::size_t I, typename... Ts>
    using find_element_t = typename find_element<I, Ts...>::type;
 
    template <std::size_t I, typename T>
    struct find_element<I, const T>
    {
        using type = std::add_const_t<find_element_t<I, T>>;
    };
 
    template <std::size_t I, typename T>
    struct find_element<I, volatile T>
    {
        using type = std::add_volatile_t<find_element_t<I, T>>;
    };
 
    template <std::size_t I, typename T>
    struct find_element<I, const volatile T>
    {
        using type = std::add_cv_t<find_element_t<I, T>>;
    };
 
    template <typename T, typename... Ts>
    struct is_alternative : std::integral_constant<bool, false>
    {
    };
 
    template <typename T, typename First, typename... Ts>
    struct is_alternative<T, First, Ts...>
    : std::integral_constant<bool, std::is_same<T, First>::value || is_alternative<T, Ts...>::value>
    {
    };
 
    template <std::size_t I, typename... Ts>
        struct is_index : std::integral_constant < bool,
        I<sizeof...(Ts)>
    {
    };
 
    template <typename T, typename... Ts>
    struct count : std::integral_constant<std::size_t, 0>
    {
    };
 
    template <typename T, typename First, typename... Ts>
    struct count<T, First, Ts...>
    : std::integral_constant<std::size_t, count<T, Ts...>::value + std::is_same<T, First>::value>
    {
    };
 
    template <typename T, typename... Ts>
    struct is_unique : std::integral_constant<bool, count<T, Ts...>::value == 1>
    {
    };
 
    template <bool... Ts>
    using all = std::is_same<std::integer_sequence<bool, true, Ts...>, std::integer_sequence<bool, Ts..., true>>;
 
    template <typename... Ts>
    struct are_copy_constructible : std::integral_constant<bool, all<std::is_copy_constructible<Ts>::value...>::value>
    {
    };
 
    template <typename... Ts>
    struct are_move_constructible : std::integral_constant<bool, all<std::is_move_constructible<Ts>::value...>::value>
    {
    };
 
    template <typename... Ts>
    struct are_copy_assignable
    : std::integral_constant<bool, are_copy_constructible<Ts...>::value && are_move_constructible<Ts...>::value &&
                                       all<std::is_copy_assignable<Ts>::value...>::value>
    {
    };
 
    template <typename... Ts>
    struct are_move_assignable : std::integral_constant<bool, are_move_constructible<Ts...>::value &&
                                                                  all<std::is_move_assignable<Ts>::value...>::value>
    {
    };
 
    struct EnableDefaultTag
    {
        explicit constexpr EnableDefaultTag () = default;
    };
 
    template <bool _Switch, typename _Tag = void>
    struct EnableDefault
    {
        constexpr EnableDefault () noexcept                     = default;
        constexpr EnableDefault (EnableDefault const&) noexcept = default;
        constexpr EnableDefault (EnableDefault&&) noexcept      = default;
 
        constexpr explicit EnableDefault (EnableDefaultTag)
        {
        }
 
        EnableDefault& operator= (EnableDefault const&) noexcept = default;
        EnableDefault& operator= (EnableDefault&&) noexcept      = default;
    };
 
    template <typename _Tag>
    struct EnableDefault<false, _Tag>
    {
        constexpr EnableDefault () noexcept                     = delete;
        constexpr EnableDefault (EnableDefault const&) noexcept = default;
        constexpr EnableDefault (EnableDefault&&) noexcept      = default;
 
        constexpr explicit EnableDefault (EnableDefaultTag)
        {
        }
 
        EnableDefault& operator= (EnableDefault const&) noexcept = default;
        EnableDefault& operator= (EnableDefault&&) noexcept      = default;
    };
}
 
#endif