summaryrefslogtreecommitdiff
path: root/boost/hana/traits.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/hana/traits.hpp')
-rw-r--r--boost/hana/traits.hpp213
1 files changed, 213 insertions, 0 deletions
diff --git a/boost/hana/traits.hpp b/boost/hana/traits.hpp
new file mode 100644
index 0000000000..2f599d78ab
--- /dev/null
+++ b/boost/hana/traits.hpp
@@ -0,0 +1,213 @@
+/*!
+@file
+Defines function-like equivalents to the standard `<type_traits>`, and also
+to some utilities like `std::declval`.
+
+@copyright Louis Dionne 2013-2016
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_HANA_TRAITS_HPP
+#define BOOST_HANA_TRAITS_HPP
+
+#include <boost/hana/config.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/type.hpp>
+
+#include <cstddef>
+#include <type_traits>
+
+
+BOOST_HANA_NAMESPACE_BEGIN namespace traits {
+ namespace detail {
+ // We use this instead of hana::integral because we want to return
+ // hana::integral_constants instead of std::integral_constants.
+ template <template <typename ...> class F>
+ struct hana_trait {
+ template <typename ...T>
+ constexpr auto operator()(T const& ...) const {
+ using Result = typename F<typename T::type...>::type;
+ return hana::integral_c<typename Result::value_type, Result::value>;
+ }
+ };
+ }
+
+ ///////////////////////
+ // Type properties
+ ///////////////////////
+ // Primary type categories
+ constexpr auto is_void = detail::hana_trait<std::is_void>{};
+ constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{};
+ constexpr auto is_integral = detail::hana_trait<std::is_integral>{};
+ constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{};
+ constexpr auto is_array = detail::hana_trait<std::is_array>{};
+ constexpr auto is_enum = detail::hana_trait<std::is_enum>{};
+ constexpr auto is_union = detail::hana_trait<std::is_union>{};
+ constexpr auto is_class = detail::hana_trait<std::is_class>{};
+ constexpr auto is_function = detail::hana_trait<std::is_function>{};
+ constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{};
+ constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{};
+ constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{};
+ constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{};
+ constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{};
+
+ // Composite type categories
+ constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{};
+ constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{};
+ constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{};
+ constexpr auto is_object = detail::hana_trait<std::is_object>{};
+ constexpr auto is_compound = detail::hana_trait<std::is_compound>{};
+ constexpr auto is_reference = detail::hana_trait<std::is_reference>{};
+ constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{};
+
+ // Type properties
+ constexpr auto is_const = detail::hana_trait<std::is_const>{};
+ constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{};
+ constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{};
+ constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{};
+ constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{};
+ constexpr auto is_pod = detail::hana_trait<std::is_pod>{};
+ constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{};
+ constexpr auto is_empty = detail::hana_trait<std::is_empty>{};
+ constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{};
+ constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{};
+ constexpr auto is_signed = detail::hana_trait<std::is_signed>{};
+ constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{};
+
+ // Supported operations
+ constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{};
+ constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{};
+ constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{};
+
+ constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{};
+ constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{};
+ constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{};
+
+ constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{};
+ constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{};
+ constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{};
+
+ constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{};
+ constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{};
+ constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{};
+
+ constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{};
+ constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{};
+ constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{};
+
+ constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{};
+ constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{};
+ constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{};
+
+ constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{};
+ constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{};
+ constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{};
+
+ constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{};
+ constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{};
+ constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{};
+
+ constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{};
+
+ // Property queries
+ constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{};
+ constexpr auto rank = detail::hana_trait<std::rank>{};
+ constexpr struct extent_t {
+ template <typename T, typename N>
+ constexpr auto operator()(T const&, N const&) const {
+ constexpr unsigned n = N::value;
+ using Result = typename std::extent<typename T::type, n>::type;
+ return hana::integral_c<typename Result::value_type, Result::value>;
+ }
+
+ template <typename T>
+ constexpr auto operator()(T const& t) const
+ { return (*this)(t, hana::uint_c<0>); }
+ } extent{};
+
+ // Type relationships
+ constexpr auto is_same = detail::hana_trait<std::is_same>{};
+ constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{};
+ constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{};
+
+ ///////////////////////
+ // Type modifications
+ ///////////////////////
+ // Const-volatility specifiers
+ constexpr auto remove_cv = metafunction<std::remove_cv>;
+ constexpr auto remove_const = metafunction<std::remove_const>;
+ constexpr auto remove_volatile = metafunction<std::remove_volatile>;
+
+ constexpr auto add_cv = metafunction<std::add_cv>;
+ constexpr auto add_const = metafunction<std::add_const>;
+ constexpr auto add_volatile = metafunction<std::add_volatile>;
+
+ // References
+ constexpr auto remove_reference = metafunction<std::remove_reference>;
+ constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>;
+ constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>;
+
+ // Pointers
+ constexpr auto remove_pointer = metafunction<std::remove_pointer>;
+ constexpr auto add_pointer = metafunction<std::add_pointer>;
+
+ // Sign modifiers
+ constexpr auto make_signed = metafunction<std::make_signed>;
+ constexpr auto make_unsigned = metafunction<std::make_unsigned>;
+
+ // Arrays
+ constexpr auto remove_extent = metafunction<std::remove_extent>;
+ constexpr auto remove_all_extents = metafunction<std::remove_all_extents>;
+
+ // Miscellaneous transformations
+ constexpr struct aligned_storage_t {
+ template <typename Len, typename Align>
+ constexpr auto operator()(Len const&, Align const&) const {
+ constexpr std::size_t len = Len::value;
+ constexpr std::size_t align = Align::value;
+ using Result = typename std::aligned_storage<len, align>::type;
+ return hana::type_c<Result>;
+ }
+
+ template <typename Len>
+ constexpr auto operator()(Len const&) const {
+ constexpr std::size_t len = Len::value;
+ using Result = typename std::aligned_storage<len>::type;
+ return hana::type_c<Result>;
+ }
+ } aligned_storage{};
+
+ constexpr struct aligned_union_t {
+ template <typename Len, typename ...T>
+ constexpr auto operator()(Len const&, T const&...) const {
+ constexpr std::size_t len = Len::value;
+ using Result = typename std::aligned_union<len, typename T::type...>::type;
+ return hana::type_c<Result>;
+ }
+ } aligned_union{};
+
+ constexpr auto decay = metafunction<std::decay>;
+ // enable_if
+ // disable_if
+ // conditional
+
+ constexpr auto common_type = metafunction<std::common_type>;
+ constexpr auto underlying_type = metafunction<std::underlying_type>;
+ constexpr auto result_of = metafunction<std::result_of>;
+
+
+ ///////////////////////
+ // Utilities
+ ///////////////////////
+ struct declval_t {
+ template <typename T>
+ typename std::add_rvalue_reference<
+ typename T::type
+ >::type operator()(T const&) const;
+ };
+
+ constexpr declval_t declval{};
+} BOOST_HANA_NAMESPACE_END
+
+#endif // !BOOST_HANA_TRAITS_HPP