1 ////////////////////////////////////////////////////////////////////////////// 2 // (C) Copyright John Maddock 2000. 3 // (C) Copyright Ion Gaztanaga 2005-2015. 4 // 5 // Distributed under the Boost Software License, Version 1.0. 6 // (See accompanying file LICENSE_1_0.txt or copy at 7 // http://www.boost.org/LICENSE_1_0.txt) 8 // 9 // See http://www.boost.org/libs/move for documentation. 10 // 11 // The alignment and Type traits implementation comes from 12 // John Maddock's TypeTraits library. 13 // 14 // Some other tricks come from Howard Hinnant's papers and StackOverflow replies 15 ////////////////////////////////////////////////////////////////////////////// 16 #ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP 17 #define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP 18 19 #ifndef BOOST_CONFIG_HPP 20 # include <boost/config.hpp> 21 #endif 22 # 23 #if defined(BOOST_HAS_PRAGMA_ONCE) 24 # pragma once 25 #endif 26 27 #include <boost/move/detail/config_begin.hpp> 28 #include <boost/move/detail/workaround.hpp> 29 30 // move/detail 31 #include <boost/move/detail/meta_utils.hpp> 32 // other 33 #include <boost/assert.hpp> 34 #include <boost/static_assert.hpp> 35 // std 36 #include <cstddef> 37 38 //Use of Boost.TypeTraits leads to long preprocessed source code due to 39 //MPL dependencies. We'll use intrinsics directly and make or own 40 //simplified version of TypeTraits. 41 //If someday Boost.TypeTraits dependencies are minimized, we should 42 //revisit this file redirecting code to Boost.TypeTraits traits. 43 44 //These traits don't care about volatile, reference or other checks 45 //made by Boost.TypeTraits because no volatile or reference types 46 //can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits 47 //dependency. 48 49 // Helper macros for builtin compiler support. 50 // If your compiler has builtin support for any of the following 51 // traits concepts, then redefine the appropriate macros to pick 52 // up on the compiler support: 53 // 54 // (these should largely ignore cv-qualifiers) 55 // BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type 56 // BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect 57 // BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy 58 // (Note: this trait does not guarantee T is copy constructible, the copy constructor could be deleted but still be trivial) 59 // BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy 60 // BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy 61 // (Note: this trait does not guarantee T is assignable , the copy assignmen could be deleted but still be trivial) 62 // BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy 63 // BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect 64 // BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw 65 // BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw 66 // BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw 67 // BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type. 68 // BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCT(T) should evaluate to true if T has a non-throwing move constructor. 69 // BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator. 70 // 71 // The following can also be defined: when detected our implementation is greatly simplified. 72 // 73 // BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T. 74 75 #if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) 76 // Metrowerks compiler is acquiring intrinsic type traits support 77 // post version 8. We hook into the published interface to pick up 78 // user defined specializations as well as compiler intrinsics as 79 // and when they become available: 80 # include <msl_utility> 81 # define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value 82 # define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value 83 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value 84 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value 85 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value 86 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value 87 #endif 88 89 #if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ 90 || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) 91 # define BOOST_MOVE_IS_UNION(T) __is_union(T) 92 # define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T)) 93 # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) 94 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) 95 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod<T>::value) 96 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod<T>::value) 97 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod<T>::value) 98 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible<T>::value) 99 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible<T>::value) 100 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable<T>::value) 101 102 # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) 103 # if defined(_MSC_VER) && (_MSC_VER >= 1700) 104 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value) 105 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value) 106 # endif 107 # if _MSC_FULL_VER >= 180020827 108 # define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&)) 109 # define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&)) 110 # endif 111 #endif 112 113 #if defined(BOOST_CLANG) 114 // BOOST_MOVE_HAS_TRAIT 115 # ifdef __has_extension 116 # define BOOST_MOVE_HAS_TRAIT(T) __has_extension(T) 117 # else 118 # define BOOST_MOVE_HAS_TRAIT(T) 0 119 # endif 120 121 // BOOST_MOVE_IS_UNION 122 # if BOOST_MOVE_HAS_TRAIT(is_union) 123 # define BOOST_MOVE_IS_UNION(T) __is_union(T) 124 # endif 125 126 // BOOST_MOVE_IS_ENUM 127 # if BOOST_MOVE_HAS_TRAIT(is_enum) 128 # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) 129 # endif 130 131 // BOOST_MOVE_IS_POD 132 # if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && BOOST_MOVE_HAS_TRAIT(is_pod) 133 # define BOOST_MOVE_IS_POD(T) __is_pod(T) 134 # endif 135 136 // BOOST_MOVE_IS_EMPTY 137 # if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && BOOST_MOVE_HAS_TRAIT(is_empty) 138 # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) 139 # endif 140 141 // BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR 142 # if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible) 143 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T) 144 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_constructor) 145 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) 146 # endif 147 148 // BOOST_MOVE_HAS_TRIVIAL_COPY 149 # if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible) 150 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__is_constructible(T, const T &) && __is_trivially_constructible(T, const T &)) 151 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_copy) 152 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T) 153 # endif 154 155 // BOOST_MOVE_HAS_TRIVIAL_ASSIGN 156 # if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable) 157 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__is_assignable(T, const T &) && __is_trivially_assignable(T, const T &)) 158 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_copy) 159 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T) 160 # endif 161 162 // BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR 163 # if BOOST_MOVE_HAS_TRAIT(is_trivially_destructible) 164 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __is_trivially_destructible(T) 165 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_destructor) 166 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) 167 # endif 168 169 // BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR 170 # if BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible) 171 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __is_nothrow_constructible(T) 172 # elif BOOST_MOVE_HAS_TRAIT(has_nothrow_constructor) 173 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) 174 # endif 175 176 // BOOST_MOVE_HAS_NOTHROW_COPY 177 # if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible) 178 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__is_constructible(T, const T &) && __is_nothrow_constructible(T, const T &)) 179 # elif BOOST_MOVE_HAS_TRAIT(has_nothrow_copy) 180 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) 181 # endif 182 183 // BOOST_MOVE_HAS_NOTHROW_ASSIGN 184 # if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_nothrow_assignable) 185 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__is_assignable(T, const T &) && __is_nothrow_assignable(T, const T &)) 186 # elif BOOST_MOVE_HAS_TRAIT(has_nothrow_assign) 187 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) 188 # endif 189 190 // BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR 191 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible) 192 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_constructible(T, T&&) && __is_trivially_constructible(T, T&&)) 193 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_constructor) 194 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T) 195 # endif 196 197 // BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN 198 # if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable) 199 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_assignable(T, T&&) && __is_trivially_assignable(T, T&&)) 200 # elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_assign) 201 # define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T) 202 # endif 203 # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T) 204 205 #endif //#if defined(BOOST_CLANG) 206 207 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) 208 209 #ifdef BOOST_INTEL 210 # define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod<T>::value 211 #else 212 # define BOOST_MOVE_INTEL_TT_OPTS 213 #endif 214 215 # define BOOST_MOVE_IS_UNION(T) __is_union(T) 216 # define BOOST_MOVE_IS_POD(T) __is_pod(T) 217 # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) 218 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)) 219 220 # if defined(BOOST_GCC) && (BOOST_GCC > 50000) 221 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__is_trivially_constructible(T, const T &)) 222 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__is_trivially_assignable(T, const T &)) 223 # else 224 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) 225 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) ) 226 # endif 227 228 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS) 229 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS) 230 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) 231 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS)) 232 233 # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) 234 # if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) 235 // GCC sometimes lies about alignment requirements 236 // of type double on 32-bit unix platforms, use the 237 // old implementation instead in that case: 238 # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) 239 # endif 240 #endif 241 242 #if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) 243 244 # define BOOST_MOVE_IS_UNION(T) __is_union(T) 245 # define BOOST_MOVE_IS_POD(T) __is_pod(T) 246 # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) 247 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) 248 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)) 249 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) 250 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) 251 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) 252 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) 253 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) 254 255 # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) 256 # define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) 257 #endif 258 259 # if defined(BOOST_CODEGEARC) 260 # define BOOST_MOVE_IS_UNION(T) __is_union(T) 261 # define BOOST_MOVE_IS_POD(T) __is_pod(T) 262 # define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) 263 # define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T)) 264 # define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T)) 265 # define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) 266 # define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)) 267 # define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T)) 268 # define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T)) 269 # define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) 270 271 # define BOOST_MOVE_IS_ENUM(T) __is_enum(T) 272 # define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T) 273 274 #endif 275 276 //Fallback definitions 277 278 #ifdef BOOST_MOVE_IS_UNION 279 #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T) 280 #else 281 #define BOOST_MOVE_IS_UNION_IMPL(T) false 282 #endif 283 284 #ifdef BOOST_MOVE_IS_POD 285 //in some compilers the intrinsic is limited to class types so add scalar and void 286 #define BOOST_MOVE_IS_POD_IMPL(T) (::boost::move_detail::is_scalar<T>::value ||\ 287 ::boost::move_detail::is_void<T>::value ||\ 288 BOOST_MOVE_IS_POD(T)) 289 #else 290 #define BOOST_MOVE_IS_POD_IMPL(T) \ 291 (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value) 292 #endif 293 294 #ifdef BOOST_MOVE_IS_EMPTY 295 #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T) 296 #else 297 #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic<T>::value 298 #endif 299 300 #ifdef BOOST_MOVE_HAS_TRIVIAL_COPY 301 #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value ||\ 302 (::boost::move_detail::is_copy_constructible<T>::value &&\ 303 BOOST_MOVE_HAS_TRIVIAL_COPY(T)) 304 #else 305 #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value 306 #endif 307 308 #ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR 309 #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value 310 #else 311 #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value 312 #endif 313 314 #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR 315 #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value 316 #else 317 #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value 318 #endif 319 320 #ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN 321 #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value ||\ 322 ( ::boost::move_detail::is_copy_assignable<T>::value &&\ 323 BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T)) 324 #else 325 #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value 326 #endif 327 328 #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN 329 #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value 330 #else 331 #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value 332 #endif 333 334 #ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR 335 #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value 336 #else 337 #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value 338 #endif 339 340 #ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR 341 #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value 342 #else 343 #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value 344 #endif 345 346 #ifdef BOOST_MOVE_HAS_NOTHROW_COPY 347 #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T) || ::boost::move_detail::is_pod<T>::value 348 #else 349 #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) 350 #endif 351 352 #ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN 353 #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value 354 #else 355 #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) 356 #endif 357 358 #ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCT 359 #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCT(T) || ::boost::move_detail::is_pod<T>::value 360 #else 361 #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) 362 #endif 363 364 #ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN 365 #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value 366 #else 367 #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) 368 #endif 369 370 #ifdef BOOST_MOVE_IS_ENUM 371 #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T) 372 #else 373 #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic<T>::value 374 #endif 375 376 namespace boost { 377 namespace move_detail { 378 379 ////////////////////////// 380 // is_reference 381 ////////////////////////// 382 template<class T> 383 struct is_reference 384 { static const bool value = false; }; 385 386 template<class T> 387 struct is_reference<T&> 388 { static const bool value = true; }; 389 390 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 391 template<class T> 392 struct is_reference<T&&> 393 { static const bool value = true; }; 394 #endif 395 396 ////////////////////////// 397 // is_pointer 398 ////////////////////////// 399 template<class T> 400 struct is_pointer 401 { static const bool value = false; }; 402 403 template<class T> 404 struct is_pointer<T*> 405 { static const bool value = true; }; 406 407 ////////////////////////// 408 // is_const 409 ////////////////////////// 410 template<class T> 411 struct is_const 412 { static const bool value = false; }; 413 414 template<class T> 415 struct is_const<const T> 416 { static const bool value = true; }; 417 418 ////////////////////////// 419 // unvoid_ref 420 ////////////////////////// 421 template <typename T> struct unvoid_ref : add_lvalue_reference<T>{}; 422 template <> struct unvoid_ref<void> { typedef unvoid_ref & type; }; 423 template <> struct unvoid_ref<const void> { typedef unvoid_ref & type; }; 424 template <> struct unvoid_ref<volatile void> { typedef unvoid_ref & type; }; 425 template <> struct unvoid_ref<const volatile void> { typedef unvoid_ref & type; }; 426 427 template <typename T> 428 struct add_reference : add_lvalue_reference<T> 429 {}; 430 431 ////////////////////////// 432 // add_const_reference 433 ////////////////////////// 434 template <class T> 435 struct add_const_reference 436 { typedef const T &type; }; 437 438 template <class T> 439 struct add_const_reference<T&> 440 { typedef T& type; }; 441 442 ////////////////////////// 443 // add_const_if_c 444 ////////////////////////// 445 template<class T, bool Add> 446 struct add_const_if_c 447 : if_c<Add, typename add_const<T>::type, T> 448 {}; 449 450 ////////////////////////// 451 // remove_const 452 ////////////////////////// 453 template<class T> 454 struct remove_const 455 { typedef T type; }; 456 457 template<class T> 458 struct remove_const< const T> 459 { typedef T type; }; 460 461 ////////////////////////// 462 // remove_cv 463 ////////////////////////// 464 template<typename T> struct remove_cv { typedef T type; }; 465 template<typename T> struct remove_cv<const T> { typedef T type; }; 466 template<typename T> struct remove_cv<const volatile T> { typedef T type; }; 467 template<typename T> struct remove_cv<volatile T> { typedef T type; }; 468 469 ////////////////////////// 470 // remove_cvref 471 ////////////////////////// 472 template<class T> 473 struct remove_cvref 474 : remove_cv<typename remove_reference<T>::type> 475 { 476 }; 477 478 ////////////////////////// 479 // make_unsigned 480 ////////////////////////// 481 template <class T> 482 struct make_unsigned_impl { typedef T type; }; 483 template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; }; 484 template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; }; 485 template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; }; 486 template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; }; 487 #ifdef BOOST_HAS_LONG_LONG 488 template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; }; 489 #endif 490 491 template <class T> 492 struct make_unsigned 493 : make_unsigned_impl<typename remove_cv<T>::type> 494 {}; 495 496 ////////////////////////// 497 // is_floating_point 498 ////////////////////////// 499 template<class T> struct is_floating_point_cv { static const bool value = false; }; 500 template<> struct is_floating_point_cv<float> { static const bool value = true; }; 501 template<> struct is_floating_point_cv<double> { static const bool value = true; }; 502 template<> struct is_floating_point_cv<long double> { static const bool value = true; }; 503 504 template<class T> 505 struct is_floating_point 506 : is_floating_point_cv<typename remove_cv<T>::type> 507 {}; 508 509 ////////////////////////// 510 // is_integral 511 ////////////////////////// 512 template<class T> struct is_integral_cv { static const bool value = false; }; 513 template<> struct is_integral_cv< bool>{ static const bool value = true; }; 514 template<> struct is_integral_cv< char>{ static const bool value = true; }; 515 template<> struct is_integral_cv< unsigned char>{ static const bool value = true; }; 516 template<> struct is_integral_cv< signed char>{ static const bool value = true; }; 517 #ifndef BOOST_NO_CXX11_CHAR16_T 518 template<> struct is_integral_cv< char16_t>{ static const bool value = true; }; 519 #endif 520 #ifndef BOOST_NO_CXX11_CHAR32_T 521 template<> struct is_integral_cv< char32_t>{ static const bool value = true; }; 522 #endif 523 #ifndef BOOST_NO_INTRINSIC_WCHAR_T 524 template<> struct is_integral_cv< wchar_t>{ static const bool value = true; }; 525 #endif 526 template<> struct is_integral_cv< short>{ static const bool value = true; }; 527 template<> struct is_integral_cv< unsigned short>{ static const bool value = true; }; 528 template<> struct is_integral_cv< int>{ static const bool value = true; }; 529 template<> struct is_integral_cv< unsigned int>{ static const bool value = true; }; 530 template<> struct is_integral_cv< long>{ static const bool value = true; }; 531 template<> struct is_integral_cv< unsigned long>{ static const bool value = true; }; 532 #ifdef BOOST_HAS_LONG_LONG 533 template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; }; 534 template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; }; 535 #endif 536 537 template<class T> 538 struct is_integral 539 : public is_integral_cv<typename remove_cv<T>::type> 540 {}; 541 542 ////////////////////////////////////// 543 // remove_all_extents 544 ////////////////////////////////////// 545 template <class T> 546 struct remove_all_extents 547 { typedef T type;}; 548 549 template <class T> 550 struct remove_all_extents<T[]> 551 { typedef typename remove_all_extents<T>::type type; }; 552 553 template <class T, std::size_t N> 554 struct remove_all_extents<T[N]> 555 { typedef typename remove_all_extents<T>::type type;}; 556 557 ////////////////////////// 558 // is_scalar 559 ////////////////////////// 560 template<class T> 561 struct is_scalar 562 { static const bool value = is_integral<T>::value || is_floating_point<T>::value; }; 563 564 ////////////////////////// 565 // is_void 566 ////////////////////////// 567 template<class T> 568 struct is_void_cv 569 { static const bool value = false; }; 570 571 template<> 572 struct is_void_cv<void> 573 { static const bool value = true; }; 574 575 template<class T> 576 struct is_void 577 : is_void_cv<typename remove_cv<T>::type> 578 {}; 579 580 ////////////////////////////////////// 581 // is_array 582 ////////////////////////////////////// 583 template<class T> 584 struct is_array 585 { static const bool value = false; }; 586 587 template<class T> 588 struct is_array<T[]> 589 { static const bool value = true; }; 590 591 template<class T, std::size_t N> 592 struct is_array<T[N]> 593 { static const bool value = true; }; 594 595 ////////////////////////////////////// 596 // is_member_pointer 597 ////////////////////////////////////// 598 template <class T> struct is_member_pointer_cv { static const bool value = false; }; 599 template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; }; 600 601 template <class T> 602 struct is_member_pointer 603 : is_member_pointer_cv<typename remove_cv<T>::type> 604 {}; 605 606 ////////////////////////////////////// 607 // is_nullptr_t 608 ////////////////////////////////////// 609 template <class T> 610 struct is_nullptr_t_cv 611 { static const bool value = false; }; 612 613 #if !defined(BOOST_NO_CXX11_NULLPTR) 614 template <> 615 struct is_nullptr_t_cv 616 #if !defined(BOOST_NO_CXX11_DECLTYPE) 617 <decltype(nullptr)> 618 #else 619 <std::nullptr_t> 620 #endif 621 { static const bool value = true; }; 622 #endif 623 624 template <class T> 625 struct is_nullptr_t 626 : is_nullptr_t_cv<typename remove_cv<T>::type> 627 {}; 628 629 ////////////////////////////////////// 630 // is_function 631 ////////////////////////////////////// 632 //Inspired by libc++, thanks to Howard Hinnant 633 //For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue 634 //pointer to that function. This does not apply to non-static member functions because lvalues 635 //that refer to non-static member functions do not exist. 636 template <class T> 637 struct is_reference_convertible_to_pointer 638 { 639 struct twochar { char dummy[2]; }; 640 template <class U> static char test(U*); 641 template <class U> static twochar test(...); 642 static T& source(); 643 static const bool value = sizeof(char) == sizeof(test<T>(source())); 644 }; 645 //Filter out: 646 // - class types that might have implicit conversions 647 // - void (to avoid forming a reference to void later) 648 // - references (e.g.: filtering reference to functions) 649 // - nullptr_t (convertible to pointer) 650 template < class T 651 , bool Filter = is_class_or_union<T>::value || 652 is_void<T>::value || 653 is_reference<T>::value || 654 is_nullptr_t<T>::value > 655 struct is_function_impl 656 { static const bool value = is_reference_convertible_to_pointer<T>::value; }; 657 658 template <class T> 659 struct is_function_impl<T, true> 660 { static const bool value = false; }; 661 662 template <class T> 663 struct is_function 664 : is_function_impl<T> 665 {}; 666 667 ////////////////////////////////////// 668 // is_union 669 ////////////////////////////////////// 670 template<class T> 671 struct is_union_noextents_cv 672 { static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); }; 673 674 template<class T> 675 struct is_union 676 : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type> 677 {}; 678 679 ////////////////////////////////////// 680 // is_class 681 ////////////////////////////////////// 682 template <class T> 683 struct is_class 684 { 685 static const bool value = is_class_or_union<T>::value && ! is_union<T>::value; 686 }; 687 688 689 ////////////////////////////////////// 690 // is_arithmetic 691 ////////////////////////////////////// 692 template <class T> 693 struct is_arithmetic 694 { 695 static const bool value = is_floating_point<T>::value || 696 is_integral<T>::value; 697 }; 698 699 ////////////////////////////////////// 700 // is_member_function_pointer 701 ////////////////////////////////////// 702 template <class T> 703 struct is_member_function_pointer_cv 704 { 705 static const bool value = false; 706 }; 707 708 template <class T, class C> 709 struct is_member_function_pointer_cv<T C::*> 710 : is_function<T> 711 {}; 712 713 template <class T> 714 struct is_member_function_pointer 715 : is_member_function_pointer_cv<typename remove_cv<T>::type> 716 {}; 717 718 ////////////////////////////////////// 719 // is_enum 720 ////////////////////////////////////// 721 #if !defined(BOOST_MOVE_IS_ENUM) 722 //Based on (http://howardhinnant.github.io/TypeHiearchy.pdf) 723 template <class T> 724 struct is_enum_nonintrinsic 725 { 726 static const bool value = !is_arithmetic<T>::value && 727 !is_reference<T>::value && 728 !is_class_or_union<T>::value && 729 !is_array<T>::value && 730 !is_void<T>::value && 731 !is_nullptr_t<T>::value && 732 !is_member_pointer<T>::value && 733 !is_pointer<T>::value && 734 !is_function<T>::value; 735 }; 736 #endif 737 738 template <class T> 739 struct is_enum 740 { static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); }; 741 742 ////////////////////////////////////// 743 // is_pod 744 ////////////////////////////////////// 745 template<class T> 746 struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback 747 { static const bool value = BOOST_MOVE_IS_POD_IMPL(T); }; 748 749 template<class T> 750 struct is_pod 751 : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type> 752 {}; 753 754 ////////////////////////////////////// 755 // is_empty 756 ////////////////////////////////////// 757 #if !defined(BOOST_MOVE_IS_EMPTY) 758 759 template <typename T> 760 struct empty_helper_t1 : public T 761 { 762 empty_helper_t1(); // hh compiler bug workaround 763 int i[256]; 764 private: 765 766 empty_helper_t1(const empty_helper_t1&); 767 empty_helper_t1& operator=(const empty_helper_t1&); 768 }; 769 770 struct empty_helper_t2 { int i[256]; }; 771 772 template <typename T, bool IsClass = is_class<T>::value > 773 struct is_empty_nonintrinsic 774 { 775 static const bool value = false; 776 }; 777 778 template <typename T> 779 struct is_empty_nonintrinsic<T, true> 780 { 781 static const bool value = sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2); 782 }; 783 #endif 784 785 template <class T> 786 struct is_empty 787 { static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); }; 788 789 790 template<class T> 791 struct has_boost_move_no_copy_constructor_or_assign_type 792 { 793 template <class U> 794 static yes_type test(typename U::boost_move_no_copy_constructor_or_assign*); 795 796 template <class U> 797 static no_type test(...); 798 799 static const bool value = sizeof(test<T>(0)) == sizeof(yes_type); 800 }; 801 802 ////////////////////////////////////// 803 // is_copy_constructible 804 ////////////////////////////////////// 805 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ 806 && !defined(BOOST_INTEL_CXX_VERSION) && \ 807 !(defined(BOOST_MSVC) && _MSC_VER == 1800) 808 #define BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE 809 #endif 810 811 template<class T> 812 struct is_copy_constructible 813 { 814 // Intel compiler has problems with SFINAE for copy constructors and deleted functions: 815 // 816 // error: function *function_name* cannot be referenced -- it is a deleted function 817 // static yes_type test(U&, decltype(U(boost::declval<U&>()))* = 0); 818 // ^ 819 // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: 820 // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken 821 #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE) 822 template<class U> static typename add_reference<U>::type source(); 823 static no_type test(...); 824 #ifdef BOOST_NO_CXX11_DECLTYPE 825 template <class U> 826 static yes_type test(U&, bool_<sizeof(U(source<U>()))>* = 0); 827 #else 828 template <class U> 829 static yes_type test(U&, decltype(U(source<U>()))* = 0); 830 #endif 831 static const bool value = sizeof(test(source<T>())) == sizeof(yes_type); 832 #else 833 static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value; 834 #endif 835 }; 836 837 838 ////////////////////////////////////// 839 // is_copy_assignable 840 ////////////////////////////////////// 841 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ 842 && !defined(BOOST_INTEL_CXX_VERSION) && \ 843 !(defined(BOOST_MSVC) && _MSC_VER == 1800) 844 #define BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE 845 #endif 846 847 template <class T> 848 struct is_copy_assignable 849 { 850 // Intel compiler has problems with SFINAE for copy constructors and deleted functions: 851 // 852 // error: function *function_name* cannot be referenced -- it is a deleted function 853 // static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0); 854 // ^ 855 // 856 // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: 857 // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken 858 #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE) 859 typedef char yes_type; 860 struct no_type { char dummy[2]; }; 861 862 template <class U> static typename add_reference<U>::type source(); 863 template <class U> static decltype(source<U&>() = source<const U&>(), yes_type() ) test(int); 864 template <class> static no_type test(...); 865 866 static const bool value = sizeof(test<T>(0)) == sizeof(yes_type); 867 #else 868 static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value; 869 #endif 870 }; 871 872 ////////////////////////////////////// 873 // is_trivially_destructible 874 ////////////////////////////////////// 875 template<class T> 876 struct is_trivially_destructible 877 { static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); }; 878 879 ////////////////////////////////////// 880 // is_trivially_default_constructible 881 ////////////////////////////////////// 882 template<class T> 883 struct is_trivially_default_constructible 884 { static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); }; 885 886 ////////////////////////////////////// 887 // is_trivially_copy_constructible 888 ////////////////////////////////////// 889 template<class T> 890 struct is_trivially_copy_constructible 891 { 892 static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T); 893 }; 894 895 ////////////////////////////////////// 896 // is_trivially_move_constructible 897 ////////////////////////////////////// 898 template<class T> 899 struct is_trivially_move_constructible 900 { static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); }; 901 902 ////////////////////////////////////// 903 // is_trivially_copy_assignable 904 ////////////////////////////////////// 905 template<class T> 906 struct is_trivially_copy_assignable 907 { 908 static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T); 909 }; 910 911 ////////////////////////////////////// 912 // is_trivially_move_assignable 913 ////////////////////////////////////// 914 template<class T> 915 struct is_trivially_move_assignable 916 { static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); }; 917 918 ////////////////////////////////////// 919 // is_nothrow_default_constructible 920 ////////////////////////////////////// 921 template<class T> 922 struct is_nothrow_default_constructible 923 { static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); }; 924 925 ////////////////////////////////////// 926 // is_nothrow_copy_constructible 927 ////////////////////////////////////// 928 template<class T> 929 struct is_nothrow_copy_constructible 930 { static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); }; 931 932 ////////////////////////////////////// 933 // is_nothrow_move_constructible 934 ////////////////////////////////////// 935 template<class T> 936 struct is_nothrow_move_constructible 937 { static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); }; 938 939 ////////////////////////////////////// 940 // is_nothrow_copy_assignable 941 ////////////////////////////////////// 942 template<class T> 943 struct is_nothrow_copy_assignable 944 { static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); }; 945 946 ////////////////////////////////////// 947 // is_nothrow_move_assignable 948 ////////////////////////////////////// 949 template<class T> 950 struct is_nothrow_move_assignable 951 { static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); }; 952 953 ////////////////////////////////////// 954 // is_nothrow_swappable 955 ////////////////////////////////////// 956 template<class T> 957 struct is_nothrow_swappable 958 { 959 static const bool value = is_empty<T>::value || is_pod<T>::value; 960 }; 961 962 ////////////////////////////////////// 963 // alignment_of 964 ////////////////////////////////////// 965 template <typename T> 966 struct alignment_of_hack 967 { 968 T t1; 969 char c; 970 T t2; 971 alignment_of_hack(); 972 ~alignment_of_hack(); 973 }; 974 975 template <unsigned A, unsigned S> 976 struct alignment_logic 977 { static const std::size_t value = A < S ? A : S; }; 978 979 template< typename T > 980 struct alignment_of_impl 981 #if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) 982 // With MSVC both the native __alignof operator 983 // and our own logic gets things wrong from time to time :-( 984 // Using a combination of the two seems to make the most of a bad job: 985 : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), __alignof(T)> 986 {}; 987 #elif !defined(BOOST_MOVE_ALIGNMENT_OF) 988 : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), sizeof(T)> 989 {}; 990 #else 991 { static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); }; 992 #endif 993 994 template< typename T > 995 struct alignment_of 996 : alignment_of_impl<T> 997 {}; 998 999 class alignment_dummy; 1000 typedef void (*function_ptr)(); 1001 typedef int (alignment_dummy::*member_ptr); 1002 typedef int (alignment_dummy::*member_function_ptr)(); 1003 struct alignment_struct 1004 { long double dummy[4]; }; 1005 1006 ///////////////////////////// 1007 // max_align_t 1008 ///////////////////////////// 1009 //This is not standard, but should work with all compilers 1010 union max_align 1011 { 1012 char char_; 1013 short short_; 1014 int int_; 1015 long long_; 1016 #ifdef BOOST_HAS_LONG_LONG 1017 ::boost::long_long_type long_long_; 1018 #endif 1019 float float_; 1020 double double_; 1021 void * void_ptr_; 1022 long double long_double_[4]; 1023 alignment_dummy *unknown_class_ptr_; 1024 function_ptr function_ptr_; 1025 member_function_ptr member_function_ptr_; 1026 alignment_struct alignment_struct_; 1027 }; 1028 1029 typedef union max_align max_align_t; 1030 1031 ///////////////////////////// 1032 // aligned_storage 1033 ///////////////////////////// 1034 1035 #if defined(_MSC_VER) && defined(_M_IX86) 1036 1037 // Special version for usual alignments on x86 MSVC because it might crash 1038 // when passsing aligned types by value even for 8 byte alignment. 1039 template<std::size_t Align> 1040 struct aligned_struct; 1041 1042 template <> struct aligned_struct<1> { char data; }; 1043 template <> struct aligned_struct<2> { short data; }; 1044 template <> struct aligned_struct<4> { int data; }; 1045 template <> struct aligned_struct<8> { double data; }; 1046 1047 #define BOOST_MOVE_ALIGNED_STRUCT(x) \ 1048 template <> struct aligned_struct<x> { \ 1049 __declspec(align(x)) char data; \ 1050 } 1051 BOOST_MOVE_ALIGNED_STRUCT(16); 1052 BOOST_MOVE_ALIGNED_STRUCT(32); 1053 BOOST_MOVE_ALIGNED_STRUCT(64); 1054 BOOST_MOVE_ALIGNED_STRUCT(128); 1055 BOOST_MOVE_ALIGNED_STRUCT(512); 1056 BOOST_MOVE_ALIGNED_STRUCT(1024); 1057 BOOST_MOVE_ALIGNED_STRUCT(2048); 1058 BOOST_MOVE_ALIGNED_STRUCT(4096); 1059 1060 template<std::size_t Len, std::size_t Align> 1061 union aligned_union 1062 { 1063 typedef aligned_struct<Align> aligner_t; 1064 aligner_t aligner; 1065 unsigned char data[Len > sizeof(aligner_t) ? Len : sizeof(aligner_t)]; 1066 }; 1067 1068 template<std::size_t Len, std::size_t Align> 1069 struct aligned_storage_impl 1070 { 1071 typedef aligned_union<Len, Align> type; 1072 }; 1073 1074 #elif !defined(BOOST_NO_ALIGNMENT) 1075 1076 template<std::size_t Len, std::size_t Align> 1077 struct aligned_struct; 1078 1079 #define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\ 1080 template<std::size_t Len>\ 1081 struct BOOST_ALIGNMENT(A) aligned_struct<Len, A>\ 1082 {\ 1083 unsigned char data[Len];\ 1084 };\ 1085 // 1086 1087 //Up to 4K alignment (typical page size) 1088 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1) 1089 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2) 1090 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4) 1091 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8) 1092 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10) 1093 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20) 1094 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40) 1095 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80) 1096 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100) 1097 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200) 1098 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400) 1099 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800) 1100 BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000) 1101 1102 #undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT 1103 1104 // Workaround for bogus [-Wignored-attributes] warning on GCC 6.x/7.x: don't use a type that "directly" carries the alignment attribute. 1105 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82270 1106 template<std::size_t Len, std::size_t Align> 1107 union aligned_struct_wrapper 1108 { 1109 typedef aligned_struct<Len, Align> aligner_t; 1110 aligned_struct<Len, Align> aligner; 1111 unsigned char data[Len > sizeof(aligner_t) ? Len : sizeof(aligner_t)]; 1112 }; 1113 1114 template<std::size_t Len, std::size_t Align> 1115 struct aligned_storage_impl 1116 { 1117 typedef aligned_struct_wrapper<Len, Align> type; 1118 }; 1119 1120 #else //BOOST_NO_ALIGNMENT 1121 1122 template<class T, std::size_t Len> 1123 union aligned_union 1124 { 1125 T aligner; 1126 unsigned char data[Len > sizeof(T) ? Len : sizeof(T)]; 1127 }; 1128 1129 template<std::size_t Len, std::size_t Align, class T, bool Ok> 1130 struct aligned_next; 1131 1132 template<std::size_t Len, std::size_t Align, class T> 1133 struct aligned_next<Len, Align, T, true> 1134 { 1135 BOOST_STATIC_ASSERT((alignment_of<T>::value == Align)); 1136 typedef aligned_union<T, Len> type; 1137 }; 1138 1139 //End of search defaults to max_align_t 1140 template<std::size_t Len, std::size_t Align> 1141 struct aligned_next<Len, Align, max_align_t, false> 1142 { typedef aligned_union<max_align_t, Len> type; }; 1143 1144 //Now define a search list through types 1145 #define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\ 1146 template<std::size_t Len, std::size_t Align>\ 1147 struct aligned_next<Len, Align, TYPE, false>\ 1148 : aligned_next<Len, Align, NEXT_TYPE, Align == alignment_of<NEXT_TYPE>::value>\ 1149 {};\ 1150 // 1151 BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t) 1152 BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double) 1153 #ifdef BOOST_HAS_LONG_LONG 1154 BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double) 1155 BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type) 1156 #else 1157 BOOST_MOVE_ALIGNED_NEXT_STEP(long, double) 1158 #endif 1159 BOOST_MOVE_ALIGNED_NEXT_STEP(int, long) 1160 BOOST_MOVE_ALIGNED_NEXT_STEP(short, int) 1161 BOOST_MOVE_ALIGNED_NEXT_STEP(char, short) 1162 #undef BOOST_MOVE_ALIGNED_NEXT_STEP 1163 1164 template<std::size_t Len, std::size_t Align> 1165 struct aligned_storage_impl 1166 : aligned_next<Len, Align, char, Align == alignment_of<char>::value> 1167 {}; 1168 1169 #endif 1170 1171 template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value> 1172 struct aligned_storage 1173 { 1174 //Sanity checks for input parameters 1175 BOOST_STATIC_ASSERT(Align > 0); 1176 1177 //Sanity checks for output type 1178 typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type; 1179 static const std::size_t value = alignment_of<type>::value; 1180 BOOST_STATIC_ASSERT(value >= Align); 1181 BOOST_STATIC_ASSERT((value % Align) == 0); 1182 1183 //Just in case someone instantiates aligned_storage 1184 //instead of aligned_storage::type (typical error). 1185 private: 1186 aligned_storage(); 1187 }; 1188 1189 } //namespace move_detail { 1190 } //namespace boost { 1191 1192 #include <boost/move/detail/config_end.hpp> 1193 1194 #endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP 1195