boost/type_traits/intrinsics.hpp

0001 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
0002 //  Use, modification and distribution are subject to the Boost Software License,
0003 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
0004 //  http://www.boost.org/LICENSE_1_0.txt).
0005 //
0006 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
0007
0008 #ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED
0009 #define BOOST_TT_INTRINSICS_HPP_INCLUDED
0010
0011 #ifndef BOOST_TT_DISABLE_INTRINSICS
0012
0013 #include <boost/config.hpp>
0014
0015 #ifndef BOOST_TT_CONFIG_HPP_INCLUDED
0016 #include <boost/type_traits/detail/config.hpp>
0017 #endif
0018
0019 //
0020 // Helper macros for builtin compiler support.
0021 // If your compiler has builtin support for any of the following
0022 // traits concepts, then redefine the appropriate macros to pick
0023 // up on the compiler support:
0024 //
0025 // (these should largely ignore cv-qualifiers)
0026 // BOOST_IS_UNION(T) should evaluate to true if T is a union type
0027 // BOOST_IS_POD(T) should evaluate to true if T is a POD type
0028 // BOOST_IS_EMPTY(T) should evaluate to true if T is an empty class type (and not a union)
0029 // BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
0030 // BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
0031 // BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy
0032 // BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
0033 // BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy
0034 // BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
0035 // BOOST_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
0036 // BOOST_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
0037 // BOOST_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
0038 // BOOST_HAS_VIRTUAL_DESTRUCTOR(T) should evaluate to true T has a virtual destructor
0039 // BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) should evaluate to true if T has a non-throwing move constructor.
0040 // BOOST_IS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator.
0041 //
0042 // The following can also be defined: when detected our implementation is greatly simplified.
0043 //
0044 // BOOST_IS_ABSTRACT(T) true if T is an abstract type
0045 // BOOST_IS_BASE_OF(T,U) true if T is a base class of U
0046 // BOOST_IS_CLASS(T) true if T is a class type (and not a union)
0047 // BOOST_IS_CONVERTIBLE(T,U) true if T is convertible to U
0048 // BOOST_IS_ENUM(T) true is T is an enum
0049 // BOOST_IS_POLYMORPHIC(T) true if T is a polymorphic type
0050 // BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T.
0051 //
0052 // define BOOST_TT_DISABLE_INTRINSICS to prevent any intrinsics being used (mostly used when testing)
0053 //
0054
0055 #ifdef BOOST_HAS_SGI_TYPE_TRAITS
0056     // Hook into SGI's __type_traits class, this will pick up user supplied
0057     // specializations as well as SGI - compiler supplied specializations.
0058 #   include <boost/type_traits/is_same.hpp>
0059 #   ifdef __NetBSD__
0060       // There are two different versions of type_traits.h on NetBSD on Spark
0061       // use an implicit include via algorithm instead, to make sure we get
0062       // the same version as the std lib:
0063 #     include <algorithm>
0064 #   else
0065 #    include <type_traits.h>
0066 #   endif
0067 #   define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits<T>::is_POD_type, ::__true_type>::value
0068 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_default_constructor, ::__true_type>::value
0069 #   define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_copy_constructor, ::__true_type>::value
0070 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_assignment_operator, ::__true_type>::value
0071 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_destructor, ::__true_type>::value
0072
0073 #   ifdef __sgi
0074 #      define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0075 #   endif
0076 #endif
0077
0078 #if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
0079     // Metrowerks compiler is acquiring intrinsic type traits support
0080     // post version 8.  We hook into the published interface to pick up
0081     // user defined specializations as well as compiler intrinsics as
0082     // and when they become available:
0083 #   include <msl_utility>
0084 #   define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value
0085 #   define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value
0086 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value
0087 #   define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value
0088 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value
0089 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value
0090 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0091 #endif
0092
0093 #if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
0094          || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
0095 //
0096 // Note that even though these intrinsics rely on other type traits classes
0097 // we do not #include those here as it produces cyclic dependencies and
0098 // can cause the intrinsics to not even be used at all!
0099 //
0100 #   define BOOST_IS_UNION(T) __is_union(T)
0101 #   define BOOST_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
0102 #   define BOOST_IS_EMPTY(T) __is_empty(T)
0103 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
0104 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ( ::boost::is_pod<T>::value && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value))
0105 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::is_pod<T>::value)
0106 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::has_trivial_constructor<T>::value)
0107 #if !defined(BOOST_INTEL)
0108 #   define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) || ::boost::has_trivial_copy<T>::value) && !is_array<T>::value)
0109 #   define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) || ::boost::is_pod<T>::value)
0110 #elif (_MSC_VER >= 1900)
0111 #   define BOOST_HAS_NOTHROW_COPY(T) ((__is_nothrow_constructible(T, typename add_lvalue_reference<typename add_const<T>::type>::type)) && !is_array<T>::value)
0112 #   define BOOST_HAS_TRIVIAL_COPY(T) (__is_trivially_constructible(T, typename add_lvalue_reference<typename add_const<T>::type>::type))
0113 #endif
0114 #   define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::has_trivial_assign<T>::value)
0115 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
0116
0117 #   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
0118 #   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
0119 #   define BOOST_IS_CLASS(T) __is_class(T)
0120 #   define BOOST_IS_CONVERTIBLE(T,U) ((__is_convertible_to(T,U) || (is_same<T,U>::value && !is_function<U>::value)) && !__is_abstract(U))
0121 #   define BOOST_IS_ENUM(T) __is_enum(T)
0122 //  This one fails if the default alignment has been changed with /Zp:
0123 //  #   define BOOST_ALIGNMENT_OF(T) __alignof(T)
0124
0125 #   if defined(_MSC_VER) && (_MSC_VER >= 1800)
0126 #       define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__is_trivially_constructible(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
0127 #       define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__is_trivially_assignable(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
0128 #   elif defined(_MSC_VER) && (_MSC_VER >= 1700)
0129 #       define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
0130 #       define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
0131 #   endif
0132 #ifndef BOOST_NO_CXX11_FINAL
0133 //  This one doesn't quite always do the right thing on older VC++ versions
0134 //  we really need it when the final keyword is supported though:
0135 #   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
0136 #endif
0137 #if _MSC_FULL_VER >= 180020827
0138 #   define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&))
0139 #   define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&))
0140 #endif
0141 #if _MSC_VER >= 1800
0142 #   define BOOST_IS_FINAL(T) __is_final(T)
0143 #endif
0144 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0145 #endif
0146
0147 #if defined(__DMC__) && (__DMC__ >= 0x848)
0148 // For Digital Mars C++, www.digitalmars.com
0149 #   define BOOST_IS_UNION(T) (__typeinfo(T) & 0x400)
0150 #   define BOOST_IS_POD(T) (__typeinfo(T) & 0x800)
0151 #   define BOOST_IS_EMPTY(T) (__typeinfo(T) & 0x1000)
0152 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__typeinfo(T) & 0x10)
0153 #   define BOOST_HAS_TRIVIAL_COPY(T) (__typeinfo(T) & 0x20)
0154 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) (__typeinfo(T) & 0x40)
0155 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__typeinfo(T) & 0x8)
0156 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__typeinfo(T) & 0x80)
0157 #   define BOOST_HAS_NOTHROW_COPY(T) (__typeinfo(T) & 0x100)
0158 #   define BOOST_HAS_NOTHROW_ASSIGN(T) (__typeinfo(T) & 0x200)
0159 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) (__typeinfo(T) & 0x4)
0160 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0161 #endif
0162
0163 #if defined(BOOST_CLANG) && defined(__has_feature) && defined(__has_builtin) && (!(defined(__CUDACC__) && (__CUDACC_VER_MAJOR__ < 11)) || defined(__CUDA__))
0164 //
0165 // Note that these intrinsics are disabled for the CUDA meta-compiler as it appears
0166 // to not support them, even though the underlying clang compiler does so.
0167 // This is a rubbish fix as it basically stops type traits from working correctly,
0168 // but maybe the best we can do for now.  See https://svn.boost.org/trac/boost/ticket/10694
0169 //
0170 //
0171 // Note that even though these intrinsics rely on other type traits classes
0172 // we do not #include those here as it produces cyclic dependencies and
0173 // can cause the intrinsics to not even be used at all!
0174 //
0175 #   include <cstddef>
0176
0177 #   if __has_feature(is_union)
0178 #     define BOOST_IS_UNION(T) __is_union(T)
0179 #   endif
0180 #   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod)
0181 #     define BOOST_IS_POD(T) __is_pod(T)
0182 #   endif
0183 #   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
0184 #     define BOOST_IS_EMPTY(T) __is_empty(T)
0185 #   endif
0186 #   if __has_builtin(__is_trivially_constructible)
0187 #     define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T)
0188 #   elif __has_feature(has_trivial_constructor)
0189 #     define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
0190 #   endif
0191 #   if __has_builtin(__is_trivially_copyable)
0192 #     define BOOST_HAS_TRIVIAL_COPY(T) (__is_trivially_copyable(T) && !is_reference<T>::value)
0193 #   elif __has_feature(has_trivial_copy)
0194 #     define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
0195 #   endif
0196 #   if __has_builtin(__is_trivially_assignable)
0197 #     define BOOST_HAS_TRIVIAL_ASSIGN(T) (__is_trivially_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
0198 #   elif __has_feature(has_trivial_assign)
0199 #     define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
0200 #   endif
0201 #   if __has_builtin(__is_trivially_destructible)
0202 #     define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__is_trivially_destructible(T)  && is_destructible<T>::value)
0203 #   elif __has_feature(has_trivial_destructor)
0204 #     define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)  && is_destructible<T>::value)
0205 #   endif
0206 #   if __has_builtin(__is_nothrow_constructible)
0207 #     define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__is_nothrow_constructible(T) && is_default_constructible<T>::value)
0208 #   elif __has_feature(has_nothrow_constructor)
0209 #     define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible<T>::value)
0210 #   endif
0211 #   if __has_builtin(__is_nothrow_constructible)
0212 #     define BOOST_HAS_NOTHROW_COPY(T) (__is_nothrow_constructible(T, const T&) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
0213 #   elif __has_feature(has_nothrow_copy)
0214 #     define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
0215 #   endif
0216 #   if __has_builtin(__is_nothrow_assignable)
0217 #     define BOOST_HAS_NOTHROW_ASSIGN(T) (__is_nothrow_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
0218 #   elif __has_feature(has_nothrow_assign)
0219 #     define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
0220 #   endif
0221 #   if __has_feature(has_virtual_destructor)
0222 #     define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
0223 #   endif
0224 #   if __has_feature(is_abstract)
0225 #     define BOOST_IS_ABSTRACT(T) __is_abstract(T)
0226 #   endif
0227 #   if __has_feature(is_base_of)
0228 #     define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
0229 #   endif
0230 #   if __has_feature(is_class)
0231 #     define BOOST_IS_CLASS(T) __is_class(T)
0232 #   endif
0233 #   if __has_feature(is_convertible_to)
0234 #     define BOOST_IS_CONVERTIBLE(T,U) __is_convertible_to(T,U)
0235 #   endif
0236 #   if __has_feature(is_enum)
0237 #     define BOOST_IS_ENUM(T) __is_enum(T)
0238 #   endif
0239 #   if __has_feature(is_polymorphic)
0240 #     define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
0241 #   endif
0242 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
0243 #   if __has_extension(is_trivially_constructible)
0244 #     define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value)
0245 #   endif
0246 #   if __has_extension(is_trivially_assignable)
0247 #     define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)
0248 #   endif
0249 #endif
0250 #   if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) || !defined(__GNUC__)
0251 // GCC sometimes lies about alignment requirements
0252 // of type double on 32-bit unix platforms, use the
0253 // old implementation instead in that case:
0254 #     define BOOST_ALIGNMENT_OF(T) __alignof(T)
0255 #   endif
0256 #   if __has_feature(is_final)
0257 #     define BOOST_IS_FINAL(T) __is_final(T)
0258 #   endif
0259
0260 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0261 #endif
0262
0263 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
0264 //
0265 // Note that even though these intrinsics rely on other type traits classes
0266 // we do not #include those here as it produces cyclic dependencies and
0267 // can cause the intrinsics to not even be used at all!
0268 //
0269
0270 #ifdef BOOST_INTEL
0271 #  define BOOST_INTEL_TT_OPTS || is_pod<T>::value
0272 #else
0273 #  define BOOST_INTEL_TT_OPTS
0274 #endif
0275
0276 #   define BOOST_IS_UNION(T) __is_union(T)
0277 #   define BOOST_IS_POD(T) __is_pod(T)
0278 #   define BOOST_IS_EMPTY(T) __is_empty(T)
0279 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
0280 #   define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value)
0281 #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409
0282 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value && is_assignable<T&, const T&>::value)
0283 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS && is_destructible<T>::value)
0284 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible<T>::value BOOST_INTEL_TT_OPTS)
0285 #   define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
0286 #   define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value && is_assignable<T&, const T&>::value)
0287 #else
0288 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
0289 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
0290 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
0291 #if ((__GNUC__ * 100 + __GNUC_MINOR__) != 407) && ((__GNUC__ * 100 + __GNUC_MINOR__) != 408)
0292 #   define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value && !is_array<T>::value)
0293 #endif
0294 #   define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value && !is_array<T>::value)
0295 #endif
0296 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
0297
0298 #   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
0299 #   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
0300 #   define BOOST_IS_CLASS(T) __is_class(T)
0301 #   define BOOST_IS_ENUM(T) __is_enum(T)
0302 #   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
0303 #   if (!defined(unix) && !defined(__unix__) && \
0304        !(defined(__VXWORKS__) && defined(__i386__)))  || defined(__LP64__)
0305       // GCC sometimes lies about alignment requirements
0306       // of type double on 32-bit unix platforms, use the
0307       // old implementation instead in that case:
0308 #     define BOOST_ALIGNMENT_OF(T) __alignof__(T)
0309 #   endif
0310 #   if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))
0311 #     define BOOST_IS_FINAL(T) __is_final(T)
0312 #   endif
0313
0314 #   if (__GNUC__ >= 5) && (__cplusplus >= 201103)
0315 #     define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)
0316 #     define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value)
0317 #   endif
0318
0319 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0320 #endif
0321
0322 #if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)
0323 #   define BOOST_IS_UNION(T) __oracle_is_union(T)
0324 #   define BOOST_IS_POD(T) (__oracle_is_pod(T) && !is_function<T>::value)
0325 #   define BOOST_IS_EMPTY(T) __oracle_is_empty(T)
0326 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__oracle_has_trivial_constructor(T) && ! ::boost::is_volatile<T>::value)
0327 #   define BOOST_HAS_TRIVIAL_COPY(T) (__oracle_has_trivial_copy(T) && !is_reference<T>::value)
0328 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value && is_assignable<T&, const T&>::value)
0329 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__oracle_has_trivial_destructor(T) && is_destructible<T>::value)
0330 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) ((__oracle_has_nothrow_constructor(T) || __oracle_has_trivial_constructor(T) || __oracle_is_trivial(T)) && is_default_constructible<T>::value)
0331 //  __oracle_has_nothrow_copy appears to behave the same as __oracle_has_nothrow_assign, disabled for now:
0332 //#   define BOOST_HAS_NOTHROW_COPY(T) ((__oracle_has_nothrow_copy(T) || __oracle_has_trivial_copy(T) || __oracle_is_trivial(T)) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
0333 #   define BOOST_HAS_NOTHROW_ASSIGN(T) ((__oracle_has_nothrow_assign(T) || __oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && !is_volatile<T>::value && !is_const<T>::value && is_assignable<T&, const T&>::value)
0334 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __oracle_has_virtual_destructor(T)
0335
0336 #   define BOOST_IS_ABSTRACT(T) __oracle_is_abstract(T)
0337 //#   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
0338 #   define BOOST_IS_CLASS(T) __oracle_is_class(T)
0339 #   define BOOST_IS_ENUM(T) __oracle_is_enum(T)
0340 #   define BOOST_IS_POLYMORPHIC(T) __oracle_is_polymorphic(T)
0341 #   define BOOST_ALIGNMENT_OF(T) __alignof__(T)
0342 #   define BOOST_IS_FINAL(T) __oracle_is_final(T)
0343
0344 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0345 #endif
0346
0347 #if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
0348 #   include <boost/type_traits/is_same.hpp>
0349 #   include <boost/type_traits/is_reference.hpp>
0350 #   include <boost/type_traits/is_volatile.hpp>
0351
0352 #   define BOOST_IS_UNION(T) __is_union(T)
0353 #   define BOOST_IS_POD(T) __is_pod(T)
0354 #   define BOOST_IS_EMPTY(T) __is_empty(T)
0355 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
0356 #   define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
0357 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value)
0358 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
0359 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
0360 #   define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value)
0361 #   define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
0362 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
0363
0364 #   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
0365 #   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
0366 #   define BOOST_IS_CLASS(T) __is_class(T)
0367 #   define BOOST_IS_ENUM(T) __is_enum(T)
0368 #   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
0369 #   define BOOST_ALIGNMENT_OF(T) __alignof__(T)
0370 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0371 #endif
0372
0373 # if defined(BOOST_CODEGEARC)
0374 #   include <boost/type_traits/is_same.hpp>
0375 #   include <boost/type_traits/is_reference.hpp>
0376 #   include <boost/type_traits/is_volatile.hpp>
0377 #   include <boost/type_traits/is_void.hpp>
0378
0379 #   define BOOST_IS_UNION(T) __is_union(T)
0380 #   define BOOST_IS_POD(T) __is_pod(T)
0381 #   define BOOST_IS_EMPTY(T) __is_empty(T)
0382 #   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T))
0383 #   define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T) && !is_reference<T>::value)
0384 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value)
0385 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T))
0386 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T))
0387 #   define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T) && !is_volatile<T>::value && !is_reference<T>::value)
0388 #   define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
0389 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
0390
0391 #   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
0392 #   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_void<T>::value && !is_void<U>::value)
0393 #   define BOOST_IS_CLASS(T) __is_class(T)
0394 #   define BOOST_IS_CONVERTIBLE(T,U) (__is_convertible(T,U) || is_void<U>::value)
0395 #   define BOOST_IS_ENUM(T) __is_enum(T)
0396 #   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
0397 #   define BOOST_ALIGNMENT_OF(T) alignof(T)
0398
0399 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
0400 #endif
0401
0402 #endif // BOOST_TT_DISABLE_INTRINSICS
0403
0404 #endif // BOOST_TT_INTRINSICS_HPP_INCLUDED
0405