traits.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_TRAITS_HPP__
#define __JOIN_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