ceph/src/boost/libs/hana/include/boost/hana/traits.hpp

   1 /*!
   2 @file
   3 Defines function-like equivalents to the standard `<type_traits>`, and also
   4 to some utilities like `std::declval`.
   5
   6 @copyright Louis Dionne 2013-2016
   7 Distributed under the Boost Software License, Version 1.0.
   8 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
   9  */
  10
  11 #ifndef BOOST_HANA_TRAITS_HPP
  12 #define BOOST_HANA_TRAITS_HPP
  13
  14 #include <boost/hana/config.hpp>
  15 #include <boost/hana/integral_constant.hpp>
  16 #include <boost/hana/type.hpp>
  17
  18 #include <cstddef>
  19 #include <type_traits>
  20
  21
  22 BOOST_HANA_NAMESPACE_BEGIN namespace traits {
  23     namespace detail {
  24         // We use this instead of hana::integral because we want to return
  25         // hana::integral_constants instead of std::integral_constants.
  26         template <template <typename ...> class F>
  27         struct hana_trait {
  28             template <typename ...T>
  29             constexpr auto operator()(T const& ...) const {
  30                 using Result = typename F<typename T::type...>::type;
  31                 return hana::integral_c<typename Result::value_type, Result::value>;
  32             }
  33         };
  34     }
  35
  36     ///////////////////////
  37     // Type properties
  38     ///////////////////////
  39     // Primary type categories
  40     constexpr auto is_void = detail::hana_trait<std::is_void>{};
  41     constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{};
  42     constexpr auto is_integral = detail::hana_trait<std::is_integral>{};
  43     constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{};
  44     constexpr auto is_array = detail::hana_trait<std::is_array>{};
  45     constexpr auto is_enum = detail::hana_trait<std::is_enum>{};
  46     constexpr auto is_union = detail::hana_trait<std::is_union>{};
  47     constexpr auto is_class = detail::hana_trait<std::is_class>{};
  48     constexpr auto is_function = detail::hana_trait<std::is_function>{};
  49     constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{};
  50     constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{};
  51     constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{};
  52     constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{};
  53     constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{};
  54
  55     // Composite type categories
  56     constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{};
  57     constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{};
  58     constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{};
  59     constexpr auto is_object = detail::hana_trait<std::is_object>{};
  60     constexpr auto is_compound = detail::hana_trait<std::is_compound>{};
  61     constexpr auto is_reference = detail::hana_trait<std::is_reference>{};
  62     constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{};
  63
  64     // Type properties
  65     constexpr auto is_const = detail::hana_trait<std::is_const>{};
  66     constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{};
  67     constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{};
  68     constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{};
  69     constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{};
  70     constexpr auto is_pod = detail::hana_trait<std::is_pod>{};
  71     constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{};
  72     constexpr auto is_empty = detail::hana_trait<std::is_empty>{};
  73     constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{};
  74     constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{};
  75     constexpr auto is_signed = detail::hana_trait<std::is_signed>{};
  76     constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{};
  77
  78     // Supported operations
  79     constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{};
  80     constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{};
  81     constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{};
  82
  83     constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{};
  84     constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{};
  85     constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{};
  86
  87     constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{};
  88     constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{};
  89     constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{};
  90
  91     constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{};
  92     constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{};
  93     constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{};
  94
  95     constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{};
  96     constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{};
  97     constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{};
  98
  99     constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{};
 100     constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{};
 101     constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{};
 102
 103     constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{};
 104     constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{};
 105     constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{};
 106
 107     constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{};
 108     constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{};
 109     constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{};
 110
 111     constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{};
 112
 113     // Property queries
 114     constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{};
 115     constexpr auto rank = detail::hana_trait<std::rank>{};
 116     constexpr struct extent_t {
 117         template <typename T, typename N>
 118         constexpr auto operator()(T const&, N const&) const {
 119             constexpr unsigned n = N::value;
 120             using Result = typename std::extent<typename T::type, n>::type;
 121             return hana::integral_c<typename Result::value_type, Result::value>;
 122         }
 123
 124         template <typename T>
 125         constexpr auto operator()(T const& t) const
 126         { return (*this)(t, hana::uint_c<0>); }
 127     } extent{};
 128
 129     // Type relationships
 130     constexpr auto is_same = detail::hana_trait<std::is_same>{};
 131     constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{};
 132     constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{};
 133
 134     ///////////////////////
 135     // Type modifications
 136     ///////////////////////
 137     // Const-volatility specifiers
 138     constexpr auto remove_cv = metafunction<std::remove_cv>;
 139     constexpr auto remove_const = metafunction<std::remove_const>;
 140     constexpr auto remove_volatile = metafunction<std::remove_volatile>;
 141
 142     constexpr auto add_cv = metafunction<std::add_cv>;
 143     constexpr auto add_const = metafunction<std::add_const>;
 144     constexpr auto add_volatile = metafunction<std::add_volatile>;
 145
 146     // References
 147     constexpr auto remove_reference = metafunction<std::remove_reference>;
 148     constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>;
 149     constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>;
 150
 151     // Pointers
 152     constexpr auto remove_pointer = metafunction<std::remove_pointer>;
 153     constexpr auto add_pointer = metafunction<std::add_pointer>;
 154
 155     // Sign modifiers
 156     constexpr auto make_signed = metafunction<std::make_signed>;
 157     constexpr auto make_unsigned = metafunction<std::make_unsigned>;
 158
 159     // Arrays
 160     constexpr auto remove_extent = metafunction<std::remove_extent>;
 161     constexpr auto remove_all_extents = metafunction<std::remove_all_extents>;
 162
 163     // Miscellaneous transformations
 164     constexpr struct aligned_storage_t {
 165         template <typename Len, typename Align>
 166         constexpr auto operator()(Len const&, Align const&) const {
 167             constexpr std::size_t len = Len::value;
 168             constexpr std::size_t align = Align::value;
 169             using Result = typename std::aligned_storage<len, align>::type;
 170             return hana::type_c<Result>;
 171         }
 172
 173         template <typename Len>
 174         constexpr auto operator()(Len const&) const {
 175             constexpr std::size_t len = Len::value;
 176             using Result = typename std::aligned_storage<len>::type;
 177             return hana::type_c<Result>;
 178         }
 179     } aligned_storage{};
 180
 181     constexpr struct aligned_union_t {
 182         template <typename Len, typename ...T>
 183         constexpr auto operator()(Len const&, T const&...) const {
 184             constexpr std::size_t len = Len::value;
 185             using Result = typename std::aligned_union<len, typename T::type...>::type;
 186             return hana::type_c<Result>;
 187         }
 188     } aligned_union{};
 189
 190     constexpr auto decay = metafunction<std::decay>;
 191     // enable_if
 192     // disable_if
 193     // conditional
 194
 195     constexpr auto common_type = metafunction<std::common_type>;
 196     constexpr auto underlying_type = metafunction<std::underlying_type>;
 197     constexpr auto result_of = metafunction<std::result_of>;
 198
 199
 200     ///////////////////////
 201     // Utilities
 202     ///////////////////////
 203     struct declval_t {
 204         template <typename T>
 205         typename std::add_rvalue_reference<
 206             typename T::type
 207         >::type operator()(T const&) const;
 208     };
 209
 210     constexpr declval_t declval{};
 211 } BOOST_HANA_NAMESPACE_END
 212
 213 #endif // !BOOST_HANA_TRAITS_HPP