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