| ////////////////////////////////////////////////////////////////////////////// |
| // (C) Copyright John Maddock 2000. |
| // (C) Copyright Ion Gaztanaga 2005-2015. |
| // |
| // Distributed under the Boost Software License, Version 1.0. |
| // (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // See http://www.boost.org/libs/move for documentation. |
| // |
| // The alignment and Type traits implementation comes from |
| // John Maddock's TypeTraits library. |
| // |
| // Some other tricks come from Howard Hinnant's papers and StackOverflow replies |
| ////////////////////////////////////////////////////////////////////////////// |
| #ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP |
| #define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP |
| |
| #ifndef BOOST_CONFIG_HPP |
| # include <boost/config.hpp> |
| #endif |
| # |
| #if defined(BOOST_HAS_PRAGMA_ONCE) |
| # pragma once |
| #endif |
| |
| #include <boost/move/detail/config_begin.hpp> |
| #include <boost/move/detail/workaround.hpp> |
| |
| // move/detail |
| #include <boost/move/detail/meta_utils.hpp> |
| // other |
| #include <boost/assert.hpp> |
| #include <boost/static_assert.hpp> |
| // std |
| #include <cstddef> |
| |
| //Use of Boost.TypeTraits leads to long preprocessed source code due to |
| //MPL dependencies. We'll use intrinsics directly and make or own |
| //simplified version of TypeTraits. |
| //If someday Boost.TypeTraits dependencies are minimized, we should |
| //revisit this file redirecting code to Boost.TypeTraits traits. |
| |
| //These traits don't care about volatile, reference or other checks |
| //made by Boost.TypeTraits because no volatile or reference types |
| //can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits |
| //dependency. |
| |
| // Helper macros for builtin compiler support. |
| // If your compiler has builtin support for any of the following |
| // traits concepts, then redefine the appropriate macros to pick |
| // up on the compiler support: |
| // |
| // (these should largely ignore cv-qualifiers) |
| // BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type |
| // BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect |
| // BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy |
| // (Note: this trait does not guarantee T is copy constructible, the copy constructor could be deleted but still be trivial) |
| // BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy |
| // BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy |
| // (Note: this trait does not guarantee T is assignable , the copy assignmen could be deleted but still be trivial) |
| // BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy |
| // BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect |
| // BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw |
| // BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw |
| // BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw |
| // BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type. |
| // |
| // The following can also be defined: when detected our implementation is greatly simplified. |
| // |
| // BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T. |
| |
| #if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) |
| // Metrowerks compiler is acquiring intrinsic type traits support |
| // post version 8. We hook into the published interface to pick up |
| // user defined specializations as well as compiler intrinsics as |
| // and when they become available: |
| # include <msl_utility> |
| # define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value |
| # define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value |
| #endif |
| |
| #if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ |
| || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) |
| # define BOOST_MOVE_IS_UNION(T) __is_union(T) |
| # define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T)) |
| # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod<T>::value) |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod<T>::value) |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod<T>::value) |
| # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible<T>::value) |
| # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible<T>::value) |
| # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable<T>::value) |
| |
| # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) |
| # if defined(_MSC_VER) && (_MSC_VER >= 1700) |
| # define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value) |
| # define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value) |
| # endif |
| #endif |
| |
| #if defined(BOOST_CLANG) && defined(__has_feature) |
| |
| # if __has_feature(is_union) |
| # define BOOST_MOVE_IS_UNION(T) __is_union(T) |
| # endif |
| # if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod) |
| # define BOOST_MOVE_IS_POD(T) __is_pod(T) |
| # endif |
| # if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty) |
| # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) |
| # endif |
| # if __has_feature(has_trivial_constructor) |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) |
| # endif |
| # if __has_feature(has_trivial_copy) |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T) |
| # endif |
| # if __has_feature(has_trivial_assign) |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) ) |
| # endif |
| # if __has_feature(has_trivial_destructor) |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) |
| # endif |
| # if __has_feature(has_nothrow_constructor) |
| # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) |
| # endif |
| # if __has_feature(has_nothrow_copy) |
| # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) |
| # endif |
| # if __has_feature(is_nothrow_copy_assignable) |
| # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) |
| # endif |
| # if __has_feature(is_enum) |
| # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) |
| # endif |
| # if __has_feature(has_trivial_move_constructor) |
| # define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T) |
| # endif |
| # if __has_feature(has_trivial_move_assign) |
| # define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T) |
| # endif |
| # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T) |
| #endif |
| |
| #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) |
| |
| #ifdef BOOST_INTEL |
| # define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod<T>::value |
| #else |
| # define BOOST_MOVE_INTEL_TT_OPTS |
| #endif |
| |
| # define BOOST_MOVE_IS_UNION(T) __is_union(T) |
| # define BOOST_MOVE_IS_POD(T) __is_pod(T) |
| # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)) |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) ) |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS) |
| # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS) |
| # define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) |
| # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS)) |
| |
| # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) |
| # if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) |
| // GCC sometimes lies about alignment requirements |
| // of type double on 32-bit unix platforms, use the |
| // old implementation instead in that case: |
| # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) |
| # endif |
| #endif |
| |
| #if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) |
| |
| # define BOOST_MOVE_IS_UNION(T) __is_union(T) |
| # define BOOST_MOVE_IS_POD(T) __is_pod(T) |
| # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)) |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) |
| # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) |
| # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) |
| # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) |
| |
| # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) |
| # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) |
| #endif |
| |
| # if defined(__CODEGEARC__) |
| # define BOOST_MOVE_IS_UNION(T) __is_union(T) |
| # define BOOST_MOVE_IS_POD(T) __is_pod(T) |
| # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) |
| # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T)) |
| # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T)) |
| # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) |
| # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)) |
| # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T)) |
| # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T)) |
| # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) |
| |
| # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) |
| # define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T) |
| |
| #endif |
| |
| //Fallback definitions |
| |
| #ifdef BOOST_MOVE_IS_UNION |
| #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T) |
| #else |
| #define BOOST_MOVE_IS_UNION_IMPL(T) false |
| #endif |
| |
| #ifdef BOOST_MOVE_IS_POD |
| //in some compilers the intrinsic is limited to class types so add scalar and void |
| #define BOOST_MOVE_IS_POD_IMPL(T) (::boost::move_detail::is_scalar<T>::value ||\ |
| ::boost::move_detail::is_void<T>::value ||\ |
| BOOST_MOVE_IS_POD(T)) |
| #else |
| #define BOOST_MOVE_IS_POD_IMPL(T) \ |
| (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value) |
| #endif |
| |
| #ifdef BOOST_MOVE_IS_EMPTY |
| #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T) |
| #else |
| #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_COPY |
| #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value ||\ |
| (::boost::move_detail::is_copy_constructible<T>::value &&\ |
| BOOST_MOVE_HAS_TRIVIAL_COPY(T)) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR |
| #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR |
| #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN |
| #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value ||\ |
| ( ::boost::move_detail::is_copy_assignable<T>::value &&\ |
| BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T)) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN |
| #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR |
| #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) |
| #else |
| #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR |
| #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) |
| #else |
| #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_NOTHROW_COPY |
| #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T) |
| #else |
| #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_NOTHROW_MOVE |
| #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE(T) |
| #else |
| #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN |
| #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) |
| #else |
| #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN |
| #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) |
| #else |
| #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value |
| #endif |
| |
| #ifdef BOOST_MOVE_IS_ENUM |
| #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T) |
| #else |
| #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic<T>::value |
| #endif |
| |
| namespace boost { |
| namespace move_detail { |
| |
| ////////////////////////// |
| // is_reference |
| ////////////////////////// |
| template<class T> |
| struct is_reference |
| { static const bool value = false; }; |
| |
| template<class T> |
| struct is_reference<T&> |
| { static const bool value = true; }; |
| |
| #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
| template<class T> |
| struct is_reference<T&&> |
| { static const bool value = true; }; |
| #endif |
| |
| ////////////////////////// |
| // is_pointer |
| ////////////////////////// |
| template<class T> |
| struct is_pointer |
| { static const bool value = false; }; |
| |
| template<class T> |
| struct is_pointer<T*> |
| { static const bool value = true; }; |
| |
| ////////////////////////// |
| // is_const |
| ////////////////////////// |
| template<class T> |
| struct is_const |
| { static const bool value = false; }; |
| |
| template<class T> |
| struct is_const<const T> |
| { static const bool value = true; }; |
| |
| ////////////////////////// |
| // unvoid_ref |
| ////////////////////////// |
| template <typename T> struct unvoid_ref : add_lvalue_reference<T>{}; |
| template <> struct unvoid_ref<void> { typedef unvoid_ref & type; }; |
| template <> struct unvoid_ref<const void> { typedef unvoid_ref & type; }; |
| template <> struct unvoid_ref<volatile void> { typedef unvoid_ref & type; }; |
| template <> struct unvoid_ref<const volatile void> { typedef unvoid_ref & type; }; |
| |
| template <typename T> |
| struct add_reference : add_lvalue_reference<T> |
| {}; |
| |
| ////////////////////////// |
| // add_const_reference |
| ////////////////////////// |
| template <class T> |
| struct add_const_reference |
| { typedef const T &type; }; |
| |
| template <class T> |
| struct add_const_reference<T&> |
| { typedef T& type; }; |
| |
| ////////////////////////// |
| // add_const_if_c |
| ////////////////////////// |
| template<class T, bool Add> |
| struct add_const_if_c |
| : if_c<Add, typename add_const<T>::type, T> |
| {}; |
| |
| ////////////////////////// |
| // remove_const |
| ////////////////////////// |
| template<class T> |
| struct remove_const |
| { typedef T type; }; |
| |
| template<class T> |
| struct remove_const< const T> |
| { typedef T type; }; |
| |
| ////////////////////////// |
| // remove_cv |
| ////////////////////////// |
| template<typename T> struct remove_cv { typedef T type; }; |
| template<typename T> struct remove_cv<const T> { typedef T type; }; |
| template<typename T> struct remove_cv<const volatile T> { typedef T type; }; |
| template<typename T> struct remove_cv<volatile T> { typedef T type; }; |
| |
| ////////////////////////// |
| // make_unsigned |
| ////////////////////////// |
| template <class T> |
| struct make_unsigned_impl { typedef T type; }; |
| template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; }; |
| template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; }; |
| template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; }; |
| template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; }; |
| #ifdef BOOST_HAS_LONG_LONG |
| template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; }; |
| #endif |
| |
| template <class T> |
| struct make_unsigned |
| : make_unsigned_impl<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////// |
| // is_floating_point |
| ////////////////////////// |
| template<class T> struct is_floating_point_cv { static const bool value = false; }; |
| template<> struct is_floating_point_cv<float> { static const bool value = true; }; |
| template<> struct is_floating_point_cv<double> { static const bool value = true; }; |
| template<> struct is_floating_point_cv<long double> { static const bool value = true; }; |
| |
| template<class T> |
| struct is_floating_point |
| : is_floating_point_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////// |
| // is_integral |
| ////////////////////////// |
| template<class T> struct is_integral_cv { static const bool value = false; }; |
| template<> struct is_integral_cv< bool>{ static const bool value = true; }; |
| template<> struct is_integral_cv< char>{ static const bool value = true; }; |
| template<> struct is_integral_cv< unsigned char>{ static const bool value = true; }; |
| template<> struct is_integral_cv< signed char>{ static const bool value = true; }; |
| #ifndef BOOST_NO_CXX11_CHAR16_T |
| template<> struct is_integral_cv< char16_t>{ static const bool value = true; }; |
| #endif |
| #ifndef BOOST_NO_CXX11_CHAR32_T |
| template<> struct is_integral_cv< char32_t>{ static const bool value = true; }; |
| #endif |
| #ifndef BOOST_NO_INTRINSIC_WCHAR_T |
| template<> struct is_integral_cv< wchar_t>{ static const bool value = true; }; |
| #endif |
| template<> struct is_integral_cv< short>{ static const bool value = true; }; |
| template<> struct is_integral_cv< unsigned short>{ static const bool value = true; }; |
| template<> struct is_integral_cv< int>{ static const bool value = true; }; |
| template<> struct is_integral_cv< unsigned int>{ static const bool value = true; }; |
| template<> struct is_integral_cv< long>{ static const bool value = true; }; |
| template<> struct is_integral_cv< unsigned long>{ static const bool value = true; }; |
| #ifdef BOOST_HAS_LONG_LONG |
| template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; }; |
| template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; }; |
| #endif |
| |
| template<class T> |
| struct is_integral |
| : public is_integral_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // remove_all_extents |
| ////////////////////////////////////// |
| template <class T> |
| struct remove_all_extents |
| { typedef T type;}; |
| |
| template <class T> |
| struct remove_all_extents<T[]> |
| { typedef typename remove_all_extents<T>::type type; }; |
| |
| template <class T, std::size_t N> |
| struct remove_all_extents<T[N]> |
| { typedef typename remove_all_extents<T>::type type;}; |
| |
| ////////////////////////// |
| // is_scalar |
| ////////////////////////// |
| template<class T> |
| struct is_scalar |
| { static const bool value = is_integral<T>::value || is_floating_point<T>::value; }; |
| |
| ////////////////////////// |
| // is_void |
| ////////////////////////// |
| template<class T> |
| struct is_void_cv |
| { static const bool value = false; }; |
| |
| template<> |
| struct is_void_cv<void> |
| { static const bool value = true; }; |
| |
| template<class T> |
| struct is_void |
| : is_void_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_array |
| ////////////////////////////////////// |
| template<class T> |
| struct is_array |
| { static const bool value = false; }; |
| |
| template<class T> |
| struct is_array<T[]> |
| { static const bool value = true; }; |
| |
| template<class T, std::size_t N> |
| struct is_array<T[N]> |
| { static const bool value = true; }; |
| |
| ////////////////////////////////////// |
| // is_member_pointer |
| ////////////////////////////////////// |
| template <class T> struct is_member_pointer_cv { static const bool value = false; }; |
| template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; }; |
| |
| template <class T> |
| struct is_member_pointer |
| : is_member_pointer_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_nullptr_t |
| ////////////////////////////////////// |
| template <class T> |
| struct is_nullptr_t_cv |
| { static const bool value = false; }; |
| |
| #if !defined(BOOST_NO_CXX11_NULLPTR) |
| template <> |
| struct is_nullptr_t_cv |
| #if !defined(BOOST_NO_CXX11_DECLTYPE) |
| <decltype(nullptr)> |
| #else |
| <std::nullptr_t> |
| #endif |
| { static const bool value = true; }; |
| #endif |
| |
| template <class T> |
| struct is_nullptr_t |
| : is_nullptr_t_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_function |
| ////////////////////////////////////// |
| //Inspired by libc++, thanks to Howard Hinnant |
| //For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue |
| //pointer to that function. This does not apply to non-static member functions because lvalues |
| //that refer to non-static member functions do not exist. |
| template <class T> |
| struct is_reference_convertible_to_pointer |
| { |
| struct twochar { char dummy[2]; }; |
| template <class U> static char test(U*); |
| template <class U> static twochar test(...); |
| static T& source(); |
| static const bool value = sizeof(char) == sizeof(test<T>(source())); |
| }; |
| //Filter out: |
| // - class types that might have implicit conversions |
| // - void (to avoid forming a reference to void later) |
| // - references (e.g.: filtering reference to functions) |
| // - nullptr_t (convertible to pointer) |
| template < class T |
| , bool Filter = is_class_or_union<T>::value || |
| is_void<T>::value || |
| is_reference<T>::value || |
| is_nullptr_t<T>::value > |
| struct is_function_impl |
| { static const bool value = is_reference_convertible_to_pointer<T>::value; }; |
| |
| template <class T> |
| struct is_function_impl<T, true> |
| { static const bool value = false; }; |
| |
| template <class T> |
| struct is_function |
| : is_function_impl<T> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_union |
| ////////////////////////////////////// |
| template<class T> |
| struct is_union_noextents_cv |
| { static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); }; |
| |
| template<class T> |
| struct is_union |
| : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_class |
| ////////////////////////////////////// |
| template <class T> |
| struct is_class |
| { |
| static const bool value = is_class_or_union<T>::value && ! is_union<T>::value; |
| }; |
| |
| |
| ////////////////////////////////////// |
| // is_arithmetic |
| ////////////////////////////////////// |
| template <class T> |
| struct is_arithmetic |
| { |
| static const bool value = is_floating_point<T>::value || |
| is_integral<T>::value; |
| }; |
| |
| ////////////////////////////////////// |
| // is_member_function_pointer |
| ////////////////////////////////////// |
| template <class T> |
| struct is_member_function_pointer_cv |
| { |
| static const bool value = false; |
| }; |
| |
| template <class T, class C> |
| struct is_member_function_pointer_cv<T C::*> |
| : is_function<T> |
| {}; |
| |
| template <class T> |
| struct is_member_function_pointer |
| : is_member_function_pointer_cv<typename remove_cv<T>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_enum |
| ////////////////////////////////////// |
| #if !defined(BOOST_MOVE_IS_ENUM) |
| //Based on (http://howardhinnant.github.io/TypeHiearchy.pdf) |
| template <class T> |
| struct is_enum_nonintrinsic |
| { |
| static const bool value = !is_arithmetic<T>::value && |
| !is_reference<T>::value && |
| !is_class_or_union<T>::value && |
| !is_array<T>::value && |
| !is_void<T>::value && |
| !is_nullptr_t<T>::value && |
| !is_member_pointer<T>::value && |
| !is_pointer<T>::value && |
| !is_function<T>::value; |
| }; |
| #endif |
| |
| template <class T> |
| struct is_enum |
| { static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); }; |
| |
| ////////////////////////////////////// |
| // is_pod |
| ////////////////////////////////////// |
| template<class T> |
| struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback |
| { static const bool value = BOOST_MOVE_IS_POD_IMPL(T); }; |
| |
| template<class T> |
| struct is_pod |
| : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type> |
| {}; |
| |
| ////////////////////////////////////// |
| // is_empty |
| ////////////////////////////////////// |
| #if !defined(BOOST_MOVE_IS_EMPTY) |
| |
| template <typename T> |
| struct empty_helper_t1 : public T |
| { |
| empty_helper_t1(); // hh compiler bug workaround |
| int i[256]; |
| private: |
| |
| empty_helper_t1(const empty_helper_t1&); |
| empty_helper_t1& operator=(const empty_helper_t1&); |
| }; |
| |
| struct empty_helper_t2 { int i[256]; }; |
| |
| template <typename T, bool IsClass = is_class<T>::value > |
| struct is_empty_nonintrinsic |
| { |
| static const bool value = false; |
| }; |
| |
| template <typename T> |
| struct is_empty_nonintrinsic<T, true> |
| { |
| static const bool value = sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2); |
| }; |
| #endif |
| |
| template <class T> |
| struct is_empty |
| { static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); }; |
| |
| |
| template<class T> |
| struct has_boost_move_no_copy_constructor_or_assign_type |
| { |
| template <class U> |
| static yes_type test(typename U::boost_move_no_copy_constructor_or_assign*); |
| |
| template <class U> |
| static no_type test(...); |
| |
| static const bool value = sizeof(test<T>(0)) == sizeof(yes_type); |
| }; |
| |
| ////////////////////////////////////// |
| // is_copy_constructible |
| ////////////////////////////////////// |
| #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ |
| && !defined(BOOST_INTEL_CXX_VERSION) && \ |
| !(defined(BOOST_MSVC) && _MSC_VER == 1800) |
| #define BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE |
| #endif |
| |
| template<class T> |
| struct is_copy_constructible |
| { |
| // Intel compiler has problems with SFINAE for copy constructors and deleted functions: |
| // |
| // error: function *function_name* cannot be referenced -- it is a deleted function |
| // static yes_type test(U&, decltype(U(boost::declval<U&>()))* = 0); |
| // ^ |
| // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: |
| // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken |
| #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE) |
| template<class U> static typename add_reference<U>::type source(); |
| static no_type test(...); |
| #ifdef BOOST_NO_CXX11_DECLTYPE |
| template <class U> |
| static yes_type test(U&, bool_<sizeof(U(source<U>()))>* = 0); |
| #else |
| template <class U> |
| static yes_type test(U&, decltype(U(source<U>()))* = 0); |
| #endif |
| static const bool value = sizeof(test(source<T>())) == sizeof(yes_type); |
| #else |
| static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value; |
| #endif |
| }; |
| |
| |
| ////////////////////////////////////// |
| // is_copy_assignable |
| ////////////////////////////////////// |
| #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ |
| && !defined(BOOST_INTEL_CXX_VERSION) && \ |
| !(defined(BOOST_MSVC) && _MSC_VER == 1800) |
| #define BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE |
| #endif |
| |
| template <class T> |
| struct is_copy_assignable |
| { |
| // Intel compiler has problems with SFINAE for copy constructors and deleted functions: |
| // |
| // error: function *function_name* cannot be referenced -- it is a deleted function |
| // static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0); |
| // ^ |
| // |
| // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: |
| // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken |
| #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE) |
| typedef char yes_type; |
| struct no_type { char dummy[2]; }; |
| |
| template <class U> static typename add_reference<U>::type source(); |
| template <class U> static decltype(source<U&>() = source<const U&>(), yes_type() ) test(int); |
| template <class> static no_type test(...); |
| |
| static const bool value = sizeof(test<T>(0)) == sizeof(yes_type); |
| #else |
| static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value; |
| #endif |
| }; |
| |
| ////////////////////////////////////// |
| // is_trivially_destructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_destructible |
| { static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_trivially_default_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_default_constructible |
| { static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_trivially_copy_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_copy_constructible |
| { |
| //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with |
| //deleted copy constructors so make sure the type is copy constructible. |
| static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T); |
| }; |
| |
| ////////////////////////////////////// |
| // is_trivially_move_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_move_constructible |
| { static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_trivially_copy_assignable |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_copy_assignable |
| { |
| //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with |
| //deleted copy constructors so make sure the type is copy constructible. |
| static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T); |
| }; |
| |
| ////////////////////////////////////// |
| // is_trivially_move_assignable |
| ////////////////////////////////////// |
| template<class T> |
| struct is_trivially_move_assignable |
| { static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_default_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_default_constructible |
| : is_pod<T> |
| { static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_copy_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_copy_constructible |
| { static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_move_constructible |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_move_constructible |
| { static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_copy_assignable |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_copy_assignable |
| { static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_move_assignable |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_move_assignable |
| { static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); }; |
| |
| ////////////////////////////////////// |
| // is_nothrow_swappable |
| ////////////////////////////////////// |
| template<class T> |
| struct is_nothrow_swappable |
| { |
| static const bool value = is_empty<T>::value || is_pod<T>::value; |
| }; |
| |
| ////////////////////////////////////// |
| // alignment_of |
| ////////////////////////////////////// |
| template <typename T> |
| struct alignment_of_hack |
| { |
| T t1; |
| char c; |
| T t2; |
| alignment_of_hack(); |
| }; |
| |
| template <unsigned A, unsigned S> |
| struct alignment_logic |
| { static const std::size_t value = A < S ? A : S; }; |
| |
| template< typename T > |
| struct alignment_of_impl |
| #if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) |
| // With MSVC both the native __alignof operator |
| // and our own logic gets things wrong from time to time :-( |
| // Using a combination of the two seems to make the most of a bad job: |
| : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), __alignof(T)> |
| {}; |
| #elif !defined(BOOST_MOVE_ALIGNMENT_OF) |
| : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), sizeof(T)> |
| {}; |
| #else |
| { static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); }; |
| #endif |
| |
| template< typename T > |
| struct alignment_of |
| : alignment_of_impl<T> |
| {}; |
| |
| class alignment_dummy; |
| typedef void (*function_ptr)(); |
| typedef int (alignment_dummy::*member_ptr); |
| typedef int (alignment_dummy::*member_function_ptr)(); |
| struct alignment_struct |
| { long double dummy[4]; }; |
| |
| ///////////////////////////// |
| // max_align_t |
| ///////////////////////////// |
| //This is not standard, but should work with all compilers |
| union max_align |
| { |
| char char_; |
| short short_; |
| int int_; |
| long long_; |
| #ifdef BOOST_HAS_LONG_LONG |
| ::boost::long_long_type long_long_; |
| #endif |
| float float_; |
| double double_; |
| void * void_ptr_; |
| long double long_double_[4]; |
| alignment_dummy *unknown_class_ptr_; |
| function_ptr function_ptr_; |
| member_function_ptr member_function_ptr_; |
| alignment_struct alignment_struct_; |
| }; |
| |
| typedef union max_align max_align_t; |
| |
| ///////////////////////////// |
| // aligned_storage |
| ///////////////////////////// |
| |
| #if !defined(BOOST_NO_ALIGNMENT) |
| |
| template<std::size_t Len, std::size_t Align> |
| struct aligned_storage_impl; |
| |
| #define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\ |
| template<std::size_t Len>\ |
| struct BOOST_ALIGNMENT(A) aligned_storage_impl<Len, A>\ |
| {\ |
| char dummy[Len];\ |
| typedef aligned_storage_impl<Len, A> type;\ |
| };\ |
| // |
| |
| //Up to 4K alignment (typical page size) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800) |
| BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000) |
| |
| #undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT |
| |
| #else //BOOST_NO_ALIGNMENT |
| |
| template<class T, std::size_t Len> |
| union aligned_union |
| { |
| T aligner; |
| char dummy[Len]; |
| }; |
| |
| template<std::size_t Len, std::size_t Align, class T, bool Ok> |
| struct aligned_next; |
| |
| template<std::size_t Len, std::size_t Align, class T> |
| struct aligned_next<Len, Align, T, true> |
| { |
| BOOST_STATIC_ASSERT((alignment_of<T>::value == Align)); |
| typedef aligned_union<T, Len> type; |
| }; |
| |
| //End of search defaults to max_align_t |
| template<std::size_t Len, std::size_t Align> |
| struct aligned_next<Len, Align, max_align_t, false> |
| { typedef aligned_union<max_align_t, Len> type; }; |
| |
| //Now define a search list through types |
| #define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\ |
| template<std::size_t Len, std::size_t Align>\ |
| struct aligned_next<Len, Align, TYPE, false>\ |
| : aligned_next<Len, Align, NEXT_TYPE, Align == alignment_of<NEXT_TYPE>::value>\ |
| {};\ |
| // |
| BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t) |
| BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double) |
| #ifdef BOOST_HAS_LONG_LONG |
| BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double) |
| BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type) |
| #else |
| BOOST_MOVE_ALIGNED_NEXT_STEP(long, double) |
| #endif |
| BOOST_MOVE_ALIGNED_NEXT_STEP(int, long) |
| BOOST_MOVE_ALIGNED_NEXT_STEP(short, int) |
| BOOST_MOVE_ALIGNED_NEXT_STEP(char, short) |
| #undef BOOST_MOVE_ALIGNED_NEXT_STEP |
| |
| template<std::size_t Len, std::size_t Align> |
| struct aligned_storage_impl |
| : aligned_next<Len, Align, char, Align == alignment_of<char>::value> |
| {}; |
| |
| #endif |
| |
| template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value> |
| struct aligned_storage |
| { |
| //Sanity checks for input parameters |
| BOOST_STATIC_ASSERT(Align > 0); |
| |
| //Sanity checks for output type |
| typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type; |
| static const std::size_t value = alignment_of<type>::value; |
| BOOST_STATIC_ASSERT(value >= Align); |
| BOOST_STATIC_ASSERT((value % Align) == 0); |
| |
| //Just in case someone instantiates aligned_storage |
| //instead of aligned_storage::type (typical error). |
| private: |
| aligned_storage(); |
| }; |
| |
| } //namespace move_detail { |
| } //namespace boost { |
| |
| #include <boost/move/detail/config_end.hpp> |
| |
| #endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP |