diff options
Diffstat (limited to '3rdParty/Boost/src/boost/type_traits')
34 files changed, 1178 insertions, 126 deletions
diff --git a/3rdParty/Boost/src/boost/type_traits/add_lvalue_reference.hpp b/3rdParty/Boost/src/boost/type_traits/add_lvalue_reference.hpp new file mode 100644 index 0000000..4156372 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/add_lvalue_reference.hpp @@ -0,0 +1,26 @@ +// Copyright 2010 John Maddock + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP +#define BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP + +#include <boost/type_traits/add_reference.hpp> + +// should be the last #include +#include <boost/type_traits/detail/type_trait_def.hpp> + +namespace boost{ + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_lvalue_reference,T,typename boost::add_reference<T>::type) + +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_lvalue_reference,T&&,T&) +#endif + +} + +#include <boost/type_traits/detail/type_trait_undef.hpp> + +#endif // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP diff --git a/3rdParty/Boost/src/boost/type_traits/add_reference.hpp b/3rdParty/Boost/src/boost/type_traits/add_reference.hpp index 7dfb4be..eb4f9b1 100644 --- a/3rdParty/Boost/src/boost/type_traits/add_reference.hpp +++ b/3rdParty/Boost/src/boost/type_traits/add_reference.hpp @@ -51,13 +51,31 @@ struct add_reference_impl }; #else +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// template <typename T> -struct add_reference_impl +struct add_reference_rvalue_layer { typedef T& type; }; +#ifndef BOOST_NO_RVALUE_REFERENCES +template <typename T> +struct add_reference_rvalue_layer<T&&> +{ + typedef T&& type; +}; +#endif + +template <typename T> +struct add_reference_impl +{ + typedef typename add_reference_rvalue_layer<T>::type type; +}; + #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) #endif diff --git a/3rdParty/Boost/src/boost/type_traits/add_rvalue_reference.hpp b/3rdParty/Boost/src/boost/type_traits/add_rvalue_reference.hpp new file mode 100644 index 0000000..00b723c --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/add_rvalue_reference.hpp @@ -0,0 +1,67 @@ +// add_rvalue_reference.hpp ---------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP +#define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP + +#include <boost/config.hpp> + +//----------------------------------------------------------------------------// + +#include <boost/type_traits/is_void.hpp> +#include <boost/type_traits/is_reference.hpp> + +// should be the last #include +#include <boost/type_traits/detail/type_trait_def.hpp> + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.7.6.2 Reference modifications [meta.trans.ref] // +// Written by Vicente J. Botet Escriba // +// // +// If T names an object or function type then the member typedef type +// shall name T&&; otherwise, type shall name T. [ Note: This rule reflects +// the semantics of reference collapsing. For example, when a type T names +// a type T1&, the type add_rvalue_reference<T>::type is not an rvalue +// reference. —end note ] +//----------------------------------------------------------------------------// + +namespace boost { + +namespace type_traits_detail { + + template <typename T, bool b> + struct add_rvalue_reference_helper + { typedef T type; }; + + template <typename T> + struct add_rvalue_reference_helper<T, true> + { +#if !defined(BOOST_NO_RVALUE_REFERENCES) + typedef T&& type; +#else + typedef T type; +#endif + }; + + template <typename T> + struct add_rvalue_reference_imp + { + typedef typename boost::type_traits_detail::add_rvalue_reference_helper + <T, (!is_void<T>::value && !is_reference<T>::value) >::type type; + }; + +} + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_rvalue_reference,T,typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type) + +} // namespace boost + +#include <boost/type_traits/detail/type_trait_undef.hpp> + +#endif // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP diff --git a/3rdParty/Boost/src/boost/type_traits/common_type.hpp b/3rdParty/Boost/src/boost/type_traits/common_type.hpp new file mode 100644 index 0000000..58525fd --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/common_type.hpp @@ -0,0 +1,153 @@ +// common_type.hpp ---------------------------------------------------------// + +// Copyright 2008 Howard Hinnant +// Copyright 2008 Beman Dawes + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_COMMON_TYPE_HPP +#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP + +#include <boost/config.hpp> + +#ifdef __SUNPRO_CC +# define BOOST_COMMON_TYPE_DONT_USE_TYPEOF +#endif +#ifdef __IBMCPP__ +# define BOOST_COMMON_TYPE_DONT_USE_TYPEOF +#endif + +//----------------------------------------------------------------------------// +#if defined(BOOST_NO_VARIADIC_TEMPLATES) +#define BOOST_COMMON_TYPE_ARITY 3 +#endif + +//----------------------------------------------------------------------------// +#if defined(BOOST_NO_DECLTYPE) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF) +#define BOOST_TYPEOF_SILENT +#include <boost/typeof/typeof.hpp> // boost wonders never cease! +#endif + +//----------------------------------------------------------------------------// +#ifndef BOOST_NO_STATIC_ASSERT +#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG) +#elif defined(BOOST_COMMON_TYPE_USES_MPL_ASSERT) +#include <boost/mpl/assert.hpp> +#include <boost/mpl/bool.hpp> +#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) \ + BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES) +#else +#include <boost/static_assert.hpp> +#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND) +#endif + +#if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_COMMON_TYPE_USES_MPL_ASSERT) +#define BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE "must be complete type" +#endif + +#if defined(BOOST_NO_DECLTYPE) && defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF) +#include <boost/type_traits/detail/common_type_imp.hpp> +#include <boost/type_traits/remove_cv.hpp> +#endif +#include <boost/mpl/if.hpp> +#include <boost/utility/declval.hpp> +#include <boost/type_traits/add_rvalue_reference.hpp> + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.6.7 Other transformations [meta.trans.other] // +// Written by Howard Hinnant // +// Adapted for Boost by Beman Dawes, Vicente Botet and Jeffrey Hellrung // +// // +//----------------------------------------------------------------------------// + +namespace boost { + +// prototype +#if !defined(BOOST_NO_VARIADIC_TEMPLATES) + template<typename... T> + struct common_type; +#else // or no specialization + template <class T, class U = void, class V = void> + struct common_type + { + public: + typedef typename common_type<typename common_type<T, U>::type, V>::type type; + }; +#endif + + +// 1 arg + template<typename T> +#if !defined(BOOST_NO_VARIADIC_TEMPLATES) + struct common_type<T> +#else + struct common_type<T, void, void> + +#endif + { + BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T)); + public: + typedef T type; + }; + +// 2 args +namespace type_traits_detail { + + template <class T, class U> + struct common_type_2 + { + private: + BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T)); + BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(U) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (U)); + static bool declval_bool(); // workaround gcc bug; not required by std + static typename add_rvalue_reference<T>::type declval_T(); // workaround gcc bug; not required by std + static typename add_rvalue_reference<U>::type declval_U(); // workaround gcc bug; not required by std + static typename add_rvalue_reference<bool>::type declval_b(); + +#if !defined(BOOST_NO_DECLTYPE) + public: + typedef decltype(declval<bool>() ? declval<T>() : declval<U>()) type; +#elif defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF) + public: + typedef typename detail_type_traits_common_type::common_type_impl< + typename remove_cv<T>::type, + typename remove_cv<U>::type + >::type type; +#else + public: + typedef BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U()) type; +#endif + }; + + template <class T> + struct common_type_2<T, T> + { + typedef T type; + }; + } + +#if !defined(BOOST_NO_VARIADIC_TEMPLATES) + template <class T, class U> + struct common_type<T, U> +#else + template <class T, class U> + struct common_type<T, U, void> +#endif + : type_traits_detail::common_type_2<T,U> + { }; + + +// 3 or more args +#if !defined(BOOST_NO_VARIADIC_TEMPLATES) + template<typename T, typename U, typename... V> + struct common_type<T, U, V...> { + public: + typedef typename common_type<typename common_type<T, U>::type, V...>::type type; + }; +#endif +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_COMMON_TYPE_HPP diff --git a/3rdParty/Boost/src/boost/type_traits/conditional.hpp b/3rdParty/Boost/src/boost/type_traits/conditional.hpp new file mode 100644 index 0000000..8bbda85 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/conditional.hpp @@ -0,0 +1,25 @@ + +// (C) Copyright John Maddock 2010. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED +#define BOOST_TT_CONDITIONAL_HPP_INCLUDED + +#include <boost/mpl/if.hpp> + +namespace boost { + +template <bool b, class T, class U> +struct conditional : public mpl::if_c<b, T, U> +{ +}; + +} // namespace boost + + +#endif // BOOST_TT_CONDITIONAL_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/type_traits/detail/common_type_imp.hpp b/3rdParty/Boost/src/boost/type_traits/detail/common_type_imp.hpp new file mode 100644 index 0000000..9e06282 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/detail/common_type_imp.hpp @@ -0,0 +1,302 @@ +/******************************************************************************* + * boost/type_traits/detail/common_type_imp.hpp + * + * Copyright 2010, Jeffrey Hellrung. + * Distributed under the Boost Software License, Version 1.0. (See accompanying + * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + * + * struct boost::common_type<T,U> + * + * common_type<T,U>::type is the type of the expression + * b() ? x() : y() + * where b() returns a bool, x() has return type T, and y() has return type U. + * See + * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm#common_type + * + * Note that this evaluates to void if one or both of T and U is void. + ******************************************************************************/ + +#ifndef BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMP_HPP +#define BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMP_HPP + +#include <cstddef> + +#include <boost/mpl/assert.hpp> +#include <boost/mpl/at.hpp> +#include <boost/mpl/begin_end.hpp> +#include <boost/mpl/contains.hpp> +#include <boost/mpl/copy.hpp> +#include <boost/mpl/deref.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/inserter.hpp> +#include <boost/mpl/next.hpp> +#include <boost/mpl/or.hpp> +#include <boost/mpl/placeholders.hpp> +#include <boost/mpl/push_back.hpp> +#include <boost/mpl/size.hpp> +#include <boost/mpl/vector/vector0.hpp> +#include <boost/mpl/vector/vector10.hpp> +#include <boost/type_traits/integral_constant.hpp> +#include <boost/type_traits/is_enum.hpp> +#include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/make_signed.hpp> +#include <boost/type_traits/make_unsigned.hpp> +#include <boost/type_traits/remove_cv.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/utility/declval.hpp> + +namespace boost +{ + +namespace detail_type_traits_common_type +{ + +/******************************************************************************* + * struct propagate_cv< From, To > + * + * This metafunction propagates cv-qualifiers on type From to type To. + ******************************************************************************/ + +template< class From, class To > +struct propagate_cv +{ typedef To type; }; +template< class From, class To > +struct propagate_cv< const From, To > +{ typedef To const type; }; +template< class From, class To > +struct propagate_cv< volatile From, To > +{ typedef To volatile type; }; +template< class From, class To > +struct propagate_cv< const volatile From, To > +{ typedef To const volatile type; }; + +/******************************************************************************* + * struct is_signable_integral<T> + * + * This metafunction determines if T is an integral type which can be made + * signed or unsigned. + ******************************************************************************/ + +template< class T > +struct is_signable_integral + : mpl::or_< is_integral<T>, is_enum<T> > +{ }; +template<> +struct is_signable_integral< bool > + : false_type +{ }; + +/******************************************************************************* + * struct sizeof_t<N> + * typedef ... yes_type + * typedef ... no_type + * + * These types are integral players in the use of the "sizeof trick", i.e., we + * can distinguish overload selection by inspecting the size of the return type + * of the overload. + ******************************************************************************/ + +template< std::size_t N > struct sizeof_t { char _dummy[N]; }; +typedef sizeof_t<1> yes_type; +typedef sizeof_t<2> no_type; +BOOST_MPL_ASSERT_RELATION( sizeof( yes_type ), ==, 1 ); +BOOST_MPL_ASSERT_RELATION( sizeof( no_type ), ==, 2 ); + +/******************************************************************************* + * rvalue_test(T&) -> no_type + * rvalue_test(...) -> yes_type + * + * These overloads are used to determine the rvalue-ness of an expression. + ******************************************************************************/ + +template< class T > no_type rvalue_test(T&); +yes_type rvalue_test(...); + +/******************************************************************************* + * struct conversion_test_overloads< Sequence > + * + * This struct has multiple overloads of the static member function apply, each + * one taking a single parameter of a type within the Boost.MPL sequence + * Sequence. Each such apply overload has a return type with sizeof equal to + * one plus the index of the parameter type within Sequence. Thus, we can + * deduce the type T of an expression as long as we can generate a finite set of + * candidate types containing T via these apply overloads and the "sizeof + * trick". + ******************************************************************************/ + +template< class First, class Last, std::size_t Index > +struct conversion_test_overloads_iterate + : conversion_test_overloads_iterate< + typename mpl::next< First >::type, Last, Index + 1 + > +{ + using conversion_test_overloads_iterate< + typename mpl::next< First >::type, Last, Index + 1 + >::apply; + static sizeof_t< Index + 1 > + apply(typename mpl::deref< First >::type); +}; + +template< class Last, std::size_t Index > +struct conversion_test_overloads_iterate< Last, Last, Index > +{ static sizeof_t< Index + 1 > apply(...); }; + +template< class Sequence > +struct conversion_test_overloads + : conversion_test_overloads_iterate< + typename mpl::begin< Sequence >::type, + typename mpl::end< Sequence >::type, + 0 + > +{ }; + +/******************************************************************************* + * struct select< Sequence, Index > + * + * select is synonymous with mpl::at_c unless Index equals the size of the + * Boost.MPL Sequence, in which case this evaluates to void. + ******************************************************************************/ + +template< + class Sequence, int Index, + int N = mpl::size< Sequence >::value +> +struct select + : mpl::at_c< Sequence, Index > +{ }; +template< class Sequence, int N > +struct select< Sequence, N, N > +{ typedef void type; }; + +/******************************************************************************* + * class deduce_common_type< T, U, NominalCandidates > + * struct nominal_candidates<T,U> + * struct common_type_dispatch_on_rvalueness<T,U> + * struct common_type_impl<T,U> + * + * These classes and structs implement the logic behind common_type, which goes + * roughly as follows. Let C be the type of the conditional expression + * declval< bool >() ? declval<T>() : declval<U>() + * if C is an rvalue, then: + * let T' and U' be T and U stripped of reference- and cv-qualifiers + * if T' and U' are pointer types, say, T' = V* and U' = W*, then: + * define the set of NominalCandidates to be + * { V*, W*, V'*, W'* } + * where V' is V with whatever cv-qualifiers are on W, and W' is W + * with whatever cv-qualifiers are on V + * else T' and U' are both "signable integral types" (integral and enum + * types excepting bool), then: + * define the set of NominalCandidates to be + * { unsigned(T'), unsigned(U'), signed(T'), signed(U') } + * where unsigned(X) is make_unsigned<X>::type and signed(X) is + * make_signed<X>::type + * else + * define the set of NominalCandidates to be + * { T', U' } + * else + * let V and W be T and U stripped of reference-qualifiers + * define the set of NominalCandidates to be + * { V&, W&, V'&, W'& } + * where V' is V with whatever cv-qualifiers are on W, and W' is W with + * whatever cv-qualifiers are on V + * define the set of Candidates to be equal to the set of NominalCandidates with + * duplicates removed, and use this set of Candidates to determine C using the + * conversion_test_overloads struct + ******************************************************************************/ + +template< class T, class U, class NominalCandidates > +class deduce_common_type +{ + typedef typename mpl::copy< + NominalCandidates, + mpl::inserter< + mpl::vector0<>, + mpl::if_< + mpl::contains< mpl::_1, mpl::_2 >, + mpl::_1, + mpl::push_back< mpl::_1, mpl::_2 > + > + > + >::type candidate_types; + static const int best_candidate_index = + sizeof( conversion_test_overloads< candidate_types >::apply( + declval< bool >() ? declval<T>() : declval<U>() + ) ) - 1; +public: + typedef typename select< candidate_types, best_candidate_index >::type type; +}; + +template< + class T, class U, + class V = typename remove_cv< typename remove_reference<T>::type >::type, + class W = typename remove_cv< typename remove_reference<U>::type >::type, + bool = is_signable_integral<V>::value && is_signable_integral<W>::value +> +struct nominal_candidates; + +template< class T, class U, class V, class W > +struct nominal_candidates< T, U, V, W, false > +{ typedef mpl::vector2<V,W> type; }; + +template< class T, class U, class V, class W > +struct nominal_candidates< T, U, V, W, true > +{ + typedef mpl::vector4< + typename make_unsigned<V>::type, + typename make_unsigned<W>::type, + typename make_signed<V>::type, + typename make_signed<W>::type + > type; +}; + +template< class T, class U, class V, class W > +struct nominal_candidates< T, U, V*, W*, false > +{ + typedef mpl::vector4< + V*, W*, + typename propagate_cv<W,V>::type *, + typename propagate_cv<V,W>::type * + > type; +}; + +template<class T, class U, bool b> +struct common_type_dispatch_on_rvalueness + : deduce_common_type< T, U, typename nominal_candidates<T,U>::type > +{ }; + +template< class T, class U > +struct common_type_dispatch_on_rvalueness< T, U, false > +{ +private: + typedef typename remove_reference<T>::type unrefed_T_type; + typedef typename remove_reference<U>::type unrefed_U_type; +public: + typedef typename deduce_common_type< + T, U, + mpl::vector4< + unrefed_T_type &, + unrefed_U_type &, + typename propagate_cv< unrefed_U_type, unrefed_T_type >::type &, + typename propagate_cv< unrefed_T_type, unrefed_U_type >::type & + > + >::type type; +}; + +template< class T, class U > +struct common_type_impl + : common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test( + declval< bool >() ? declval<T>() : declval<U>() ) ) == sizeof( yes_type ) > +{ }; + +template< class T > struct common_type_impl< T, void > { typedef void type; }; +template< class T > struct common_type_impl< void, T > { typedef void type; }; +template<> struct common_type_impl< void, void > { typedef void type; }; + +} // namespace detail_type_traits_common_type + + +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_HPP + diff --git a/3rdParty/Boost/src/boost/type_traits/function_traits.hpp b/3rdParty/Boost/src/boost/type_traits/function_traits.hpp index bfc3f7e..6d708cd 100644 --- a/3rdParty/Boost/src/boost/type_traits/function_traits.hpp +++ b/3rdParty/Boost/src/boost/type_traits/function_traits.hpp @@ -166,7 +166,7 @@ struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> template<typename Function> struct function_traits : - public detail::function_traits_helper<typename boost::add_pointer<Function>::type> + public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type> { }; @@ -227,7 +227,7 @@ type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, template<typename Function> struct function_traits { - BOOST_STATIC_CONSTANT(unsigned, arity = (sizeof(detail::function_arity_helper((Function*)0))-1)); + BOOST_STATIC_CONSTANT(unsigned, arity = (sizeof(boost::detail::function_arity_helper((Function*)0))-1)); }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION diff --git a/3rdParty/Boost/src/boost/type_traits/has_new_operator.hpp b/3rdParty/Boost/src/boost/type_traits/has_new_operator.hpp new file mode 100644 index 0000000..2c2c322 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/has_new_operator.hpp @@ -0,0 +1,140 @@ + +// (C) Copyright Runar Undheim, Robert Ramey & John Maddock 2008. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED +#define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED + +#include <new> // std::nothrow_t +#include <cstddef> // std::size_t +#include <boost/type_traits/config.hpp> +#include <boost/type_traits/detail/yes_no_type.hpp> +#include <boost/type_traits/detail/ice_or.hpp> + +// should be the last #include +#include <boost/type_traits/detail/bool_trait_def.hpp> + +namespace boost { +namespace detail { + template <class U, U x> + struct test; + + template <typename T> + struct has_new_operator_impl { + template<class U> + static type_traits::yes_type check_sig1( + U*, + test< + void *(*)(std::size_t), + &U::operator new + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig1(...); + + template<class U> + static type_traits::yes_type check_sig2( + U*, + test< + void *(*)(std::size_t, const std::nothrow_t&), + &U::operator new + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig2(...); + + template<class U> + static type_traits::yes_type check_sig3( + U*, + test< + void *(*)(std::size_t, void*), + &U::operator new + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig3(...); + + + template<class U> + static type_traits::yes_type check_sig4( + U*, + test< + void *(*)(std::size_t), + &U::operator new[] + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig4(...); + + template<class U> + static type_traits::yes_type check_sig5( + U*, + test< + void *(*)(std::size_t, const std::nothrow_t&), + &U::operator new[] + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig5(...); + + template<class U> + static type_traits::yes_type check_sig6( + U*, + test< + void *(*)(std::size_t, void*), + &U::operator new[] + >* = NULL + ); + template<class U> + static type_traits::no_type check_sig6(...); + + // GCC2 won't even parse this template if we embed the computation + // of s1 in the computation of value. + #ifdef __GNUC__ + BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(has_new_operator_impl<T>::template check_sig1<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(has_new_operator_impl<T>::template check_sig2<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(has_new_operator_impl<T>::template check_sig3<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(has_new_operator_impl<T>::template check_sig4<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(has_new_operator_impl<T>::template check_sig5<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(has_new_operator_impl<T>::template check_sig6<T>(0))); + #else + #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) + #pragma warning(push) + #pragma warning(disable:6334) + #endif + + BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check_sig1<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(check_sig2<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(check_sig3<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(check_sig4<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(check_sig5<T>(0))); + BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(check_sig6<T>(0))); + + #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) + #pragma warning(pop) + #endif + #endif + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + (s1 == sizeof(type_traits::yes_type)), + (s2 == sizeof(type_traits::yes_type)), + (s3 == sizeof(type_traits::yes_type)), + (s4 == sizeof(type_traits::yes_type)), + (s5 == sizeof(type_traits::yes_type)), + (s6 == sizeof(type_traits::yes_type)) + >::value) + ); + }; +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_new_operator,T,::boost::detail::has_new_operator_impl<T>::value) + +} // namespace boost + +#include <boost/type_traits/detail/bool_trait_undef.hpp> + +#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/type_traits/intrinsics.hpp b/3rdParty/Boost/src/boost/type_traits/intrinsics.hpp index 8f88036..9666456 100644 --- a/3rdParty/Boost/src/boost/type_traits/intrinsics.hpp +++ b/3rdParty/Boost/src/boost/type_traits/intrinsics.hpp @@ -159,6 +159,33 @@ # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif +#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) +# include <boost/type_traits/is_same.hpp> +# include <boost/type_traits/is_reference.hpp> +# include <boost/type_traits/is_volatile.hpp> + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + # if defined(__CODEGEARC__) # include <boost/type_traits/is_same.hpp> # include <boost/type_traits/is_reference.hpp> diff --git a/3rdParty/Boost/src/boost/type_traits/is_complex.hpp b/3rdParty/Boost/src/boost/type_traits/is_complex.hpp index 9ccc333..0813dac 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_complex.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_complex.hpp @@ -25,7 +25,7 @@ struct is_convertible_from_tester } -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_complex,T,(::boost::is_convertible<T, detail::is_convertible_from_tester>::value)) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_complex,T,(::boost::is_convertible<T, boost::detail::is_convertible_from_tester>::value)) } // namespace boost diff --git a/3rdParty/Boost/src/boost/type_traits/is_const.hpp b/3rdParty/Boost/src/boost/type_traits/is_const.hpp index e66d18a..812ed15 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_const.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_const.hpp @@ -50,12 +50,31 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T)) #elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -//* is a type T declared const - is_const<T> +namespace detail{ +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template <class T> +struct is_const_rvalue_filter +{ #if BOOST_WORKAROUND(BOOST_MSVC, < 1400) - BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::cv_traits_imp<typename remove_bounds<T>::type*>::is_const) + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_const); #else - BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::cv_traits_imp<T*>::is_const) + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<T*>::is_const); +#endif +}; +#ifndef BOOST_NO_RVALUE_REFERENCES +template <class T> +struct is_const_rvalue_filter<T&&> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; #endif +} + +//* is a type T declared const - is_const<T> +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_rvalue_filter<T>::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false) #if defined(BOOST_ILLEGAL_CV_REFERENCES) @@ -98,7 +117,7 @@ struct is_const_helper<false,false> { static T* t; BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(detail::yes_type) == sizeof(detail::is_const_tester(t)) + sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(t)) )); }; }; @@ -110,7 +129,7 @@ struct is_const_helper<false,true> { static T t; BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(detail::yes_type) == sizeof(detail::is_const_tester(&t)) + sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(&t)) )); }; }; diff --git a/3rdParty/Boost/src/boost/type_traits/is_convertible.hpp b/3rdParty/Boost/src/boost/type_traits/is_convertible.hpp index a31a930..c05c297 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_convertible.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_convertible.hpp @@ -132,7 +132,7 @@ template <typename From, typename To> struct is_convertible_basic_impl { static From _m_from; - static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) ) + static bool const value = sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type); }; diff --git a/3rdParty/Boost/src/boost/type_traits/is_function.hpp b/3rdParty/Boost/src/boost/type_traits/is_function.hpp index 95dba0d..55c05c1 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_function.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_function.hpp @@ -95,6 +95,9 @@ struct is_function_impl<T&> : public false_type BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,__is_function(T)) #else BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl<T>::value) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_function,T&&,false) +#endif #endif } // namespace boost diff --git a/3rdParty/Boost/src/boost/type_traits/is_lvalue_reference.hpp b/3rdParty/Boost/src/boost/type_traits/is_lvalue_reference.hpp new file mode 100644 index 0000000..a6af859 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/is_lvalue_reference.hpp @@ -0,0 +1,118 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_lvalue_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic<Programming>: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED + +#include <boost/type_traits/config.hpp> + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include <boost/type_traits/detail/yes_no_type.hpp> +# include <boost/type_traits/detail/wrap.hpp> +#endif + +// should be the last #include +#include <boost/type_traits/detail/bool_trait_def.hpp> + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,__is_reference(T)) +#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T&,true) + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const volatile,true) +#endif + +#if defined(__GNUC__) && (__GNUC__ < 3) +// these allow us to work around illegally cv-qualified reference +// types. +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const ,::boost::is_lvalue_reference<T>::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T volatile ,::boost::is_lvalue_reference<T>::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const volatile ,::boost::is_lvalue_reference<T>::value) +// However, the above specializations confuse gcc 2.96 unless we also +// supply these specializations for array types +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,volatile T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const volatile T[N],false) +#endif + +#else + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4181 4097) +#endif + +namespace detail { + +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; +using ::boost::type_traits::wrap; + +template <class T> T&(* is_lvalue_reference_helper1(wrap<T>) )(wrap<T>); +char is_lvalue_reference_helper1(...); + +template <class T> no_type is_lvalue_reference_helper2(T&(*)(wrap<T>)); +yes_type is_lvalue_reference_helper2(...); + +template <typename T> +struct is_lvalue_reference_impl +{ + BOOST_STATIC_CONSTANT( + bool, value = sizeof( + ::boost::detail::is_lvalue_reference_helper2( + ::boost::detail::is_lvalue_reference_helper1(::boost::type_traits::wrap<T>()))) == 1 + ); +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,::boost::detail::is_lvalue_reference_impl<T>::value) + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include <boost/type_traits/detail/bool_trait_undef.hpp> + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/3rdParty/Boost/src/boost/type_traits/is_reference.hpp b/3rdParty/Boost/src/boost/type_traits/is_reference.hpp index dcf84db..49b5f9f 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_reference.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_reference.hpp @@ -1,6 +1,6 @@ // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, -// Howard Hinnant and John Maddock 2000. +// Howard Hinnant and John Maddock 2000, 2010. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, @@ -9,107 +9,34 @@ // // See http://www.boost.org/libs/type_traits for most recent version including documentation. -// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, -// is_member_pointer based on the Simulated Partial Specialization work -// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or -// http://groups.yahoo.com/group/boost/message/5441 -// Some workarounds in here use ideas suggested from "Generic<Programming>: -// Mappings between Types and Values" -// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). - - #ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED #define BOOST_TT_IS_REFERENCE_HPP_INCLUDED #include <boost/type_traits/config.hpp> - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# include <boost/type_traits/detail/yes_no_type.hpp> -# include <boost/type_traits/detail/wrap.hpp> -#endif +#include <boost/type_traits/is_lvalue_reference.hpp> +#include <boost/type_traits/is_rvalue_reference.hpp> +#include <boost/type_traits/ice.hpp> // should be the last #include #include <boost/type_traits/detail/bool_trait_def.hpp> namespace boost { -#if defined( __CODEGEARC__ ) -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,__is_reference(T)) -#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T&,true) - -#if defined(BOOST_ILLEGAL_CV_REFERENCES) -// these are illegal specialisations; cv-qualifies applied to -// references have no effect according to [8.3.2p1], -// C++ Builder requires them though as it treats cv-qualified -// references as distinct types... -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const,true) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& volatile,true) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const volatile,true) -#endif - -#if defined(__GNUC__) && (__GNUC__ < 3) -// these allow us to work around illegally cv-qualified reference -// types. -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const ,::boost::is_reference<T>::value) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T volatile ,::boost::is_reference<T>::value) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const volatile ,::boost::is_reference<T>::value) -// However, the above specializations confuse gcc 2.96 unless we also -// supply these specializations for array types -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,volatile T[N],false) -BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const volatile T[N],false) -#endif - -#else - -#ifdef BOOST_MSVC -# pragma warning(push) -# pragma warning(disable: 4181 4097) -#endif - namespace detail { -using ::boost::type_traits::yes_type; -using ::boost::type_traits::no_type; -using ::boost::type_traits::wrap; - -template <class T> T&(* is_reference_helper1(wrap<T>) )(wrap<T>); -char is_reference_helper1(...); - -template <class T> no_type is_reference_helper2(T&(*)(wrap<T>)); -yes_type is_reference_helper2(...); - template <typename T> struct is_reference_impl { - BOOST_STATIC_CONSTANT( - bool, value = sizeof( - ::boost::detail::is_reference_helper2( - ::boost::detail::is_reference_helper1(::boost::type_traits::wrap<T>()))) == 1 - ); + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value + >::value)); }; -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void,false) -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void volatile,false) -BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const volatile,false) -#endif - } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,::boost::detail::is_reference_impl<T>::value) -#ifdef BOOST_MSVC -# pragma warning(pop) -#endif - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - } // namespace boost #include <boost/type_traits/detail/bool_trait_undef.hpp> diff --git a/3rdParty/Boost/src/boost/type_traits/is_rvalue_reference.hpp b/3rdParty/Boost/src/boost/type_traits/is_rvalue_reference.hpp new file mode 100644 index 0000000..cac2ee0 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/is_rvalue_reference.hpp @@ -0,0 +1,29 @@ + +// (C) John Maddock 2010. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED + +#include <boost/type_traits/config.hpp> + +// should be the last #include +#include <boost/type_traits/detail/bool_trait_def.hpp> + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_rvalue_reference,T,false) +#ifndef BOOST_NO_RVALUE_REFERENCES +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_rvalue_reference,T&&,true) +#endif + +} // namespace boost + +#include <boost/type_traits/detail/bool_trait_undef.hpp> + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/3rdParty/Boost/src/boost/type_traits/is_same.hpp b/3rdParty/Boost/src/boost/type_traits/is_same.hpp index e0d1808..c6afbd7 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_same.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_same.hpp @@ -61,7 +61,7 @@ struct is_same_part_1 template< typename T1, typename T2 > struct is_same_impl { - enum { value = detail::is_same_part_1<T1>::template part_2<T2>::value }; + enum { value = boost::detail::is_same_part_1<T1>::template part_2<T2>::value }; }; #else // generic "no-partial-specialization" version @@ -81,7 +81,7 @@ struct is_same_impl BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< - (sizeof(type_traits::yes_type) == sizeof(detail::is_same_tester(&t,&u))), + (sizeof(type_traits::yes_type) == sizeof(boost::detail::is_same_tester(&t,&u))), (::boost::is_reference<T>::value == ::boost::is_reference<U>::value), (sizeof(T) == sizeof(U)) >::value)); diff --git a/3rdParty/Boost/src/boost/type_traits/is_signed.hpp b/3rdParty/Boost/src/boost/type_traits/is_signed.hpp index bf7bbfd..ba7d6e9 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_signed.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_signed.hpp @@ -24,14 +24,19 @@ namespace boost { namespace detail{ -#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) +#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) template <class T> struct is_signed_values { + // + // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's + // rather than "real" static constants simply doesn't work or give + // the correct answer. + // typedef typename remove_cv<T>::type no_cv_t; - BOOST_STATIC_CONSTANT(no_cv_t, minus_one = (static_cast<no_cv_t>(-1))); - BOOST_STATIC_CONSTANT(no_cv_t, zero = (static_cast<no_cv_t>(0))); + static const no_cv_t minus_one = (static_cast<no_cv_t>(-1)); + static const no_cv_t zero = (static_cast<no_cv_t>(0)); }; template <class T> diff --git a/3rdParty/Boost/src/boost/type_traits/is_unsigned.hpp b/3rdParty/Boost/src/boost/type_traits/is_unsigned.hpp index 98baf4e..d8e5a89 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_unsigned.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_unsigned.hpp @@ -24,14 +24,19 @@ namespace boost { namespace detail{ -#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) +#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) template <class T> struct is_unsigned_values { + // + // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's + // rather than "real" static constants simply doesn't work or give + // the correct answer. + // typedef typename remove_cv<T>::type no_cv_t; - BOOST_STATIC_CONSTANT(no_cv_t, minus_one = (static_cast<no_cv_t>(-1))); - BOOST_STATIC_CONSTANT(no_cv_t, zero = (static_cast<no_cv_t>(0))); + static const no_cv_t minus_one = (static_cast<no_cv_t>(-1)); + static const no_cv_t zero = (static_cast<no_cv_t>(0)); }; template <class T> diff --git a/3rdParty/Boost/src/boost/type_traits/is_virtual_base_of.hpp b/3rdParty/Boost/src/boost/type_traits/is_virtual_base_of.hpp new file mode 100644 index 0000000..98ab159 --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/is_virtual_base_of.hpp @@ -0,0 +1,104 @@ +// (C) Copyright Daniel Frey and Robert Ramey 2009. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_VIRTUAL_BASE_OF_HPP_INCLUDED +#define BOOST_TT_IS_VIRTUAL_BASE_OF_HPP_INCLUDED + +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> + +// should be the last #include +#include <boost/type_traits/detail/bool_trait_def.hpp> + +namespace boost { +namespace detail { + + +#ifdef BOOST_MSVC +#pragma warning( push ) +#pragma warning( disable : 4584 ) +#elif defined __GNUC__ +#pragma GCC system_header +#endif + +template<typename Base, typename Derived, typename tag> +struct is_virtual_base_of_impl +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template<typename Base, typename Derived> +struct is_virtual_base_of_impl<Base, Derived, mpl::true_> +{ +#ifdef __BORLANDC__ + struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base + { + boost_type_traits_internal_struct_X(); + boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); + boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); + ~boost_type_traits_internal_struct_X()throw(); + }; + struct boost_type_traits_internal_struct_Y : public virtual Derived + { + boost_type_traits_internal_struct_Y(); + boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); + boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); + ~boost_type_traits_internal_struct_Y()throw(); + }; +#else + struct boost_type_traits_internal_struct_X : Derived, virtual Base + { + boost_type_traits_internal_struct_X(); + boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); + boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); + ~boost_type_traits_internal_struct_X()throw(); + }; + struct boost_type_traits_internal_struct_Y : Derived + { + boost_type_traits_internal_struct_Y(); + boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); + boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); + ~boost_type_traits_internal_struct_Y()throw(); + }; +#endif + BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y))); +}; + +template<typename Base, typename Derived> +struct is_virtual_base_of_impl2 +{ + typedef typename mpl::and_<is_base_of<Base, Derived>, mpl::not_<is_same<Base, Derived> > >::type tag_type; + typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp; + BOOST_STATIC_CONSTANT(bool, value = imp::value); +}; + +#ifdef BOOST_MSVC +#pragma warning( pop ) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2( + is_virtual_base_of + , Base + , Derived + , (::boost::detail::is_virtual_base_of_impl2<Base,Derived>::value) +) + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base,Derived&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived&,false) +#endif + +} // namespace boost + +#include <boost/type_traits/detail/bool_trait_undef.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/type_traits/is_volatile.hpp b/3rdParty/Boost/src/boost/type_traits/is_volatile.hpp index 7ab253a..e531263 100644 --- a/3rdParty/Boost/src/boost/type_traits/is_volatile.hpp +++ b/3rdParty/Boost/src/boost/type_traits/is_volatile.hpp @@ -41,16 +41,35 @@ namespace boost { +namespace detail{ +template <class T> +struct is_volatile_rval_filter +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1400) + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_volatile); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<T*>::is_volatile); +#endif +}; +#ifndef BOOST_NO_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template <class T> +struct is_volatile_rval_filter<T&&> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif +} + #if defined( __CODEGEARC__ ) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,__is_volatile(T)) #elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) //* is a type T declared volatile - is_volatile<T> -#if BOOST_WORKAROUND(BOOST_MSVC, < 1400) - BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_volatile) -#else - BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::cv_traits_imp<T*>::is_volatile) -#endif +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_rval_filter<T>::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T&,false) #if defined(BOOST_ILLEGAL_CV_REFERENCES) @@ -86,7 +105,7 @@ struct is_volatile_helper<false,false> { static T* t; BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(t)) + sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(t)) )); }; }; @@ -98,7 +117,7 @@ struct is_volatile_helper<false,true> { static T t; BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(&t)) + sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(&t)) )); }; }; diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_all_extents.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_all_extents.hpp index 3517132..25c0edf 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_all_extents.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_all_extents.hpp @@ -36,7 +36,7 @@ namespace boost { template<typename T> struct remove_all_extents { - typedef typename detail::remove_all_extents_impl_typeof< + typedef typename boost::detail::remove_all_extents_impl_typeof< boost::is_array<T>::value >::template inner<T,remove_all_extents<T> >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_all_extents,T) diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_bounds.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_bounds.hpp index 12a9b05..4b23b35 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_bounds.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_bounds.hpp @@ -32,7 +32,7 @@ namespace boost { template<typename T> struct remove_bounds { - typedef typename detail::remove_bounds_impl_typeof< + typedef typename boost::detail::remove_bounds_impl_typeof< boost::is_array<T>::value >::template inner<T,remove_bounds<T> >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_bounds,T) diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_const.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_const.hpp index 5395e80..d370754 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_const.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_const.hpp @@ -124,7 +124,7 @@ namespace boost { template<typename T> struct remove_const { - typedef detail::remove_const_impl_typeof< + typedef boost::detail::remove_const_impl_typeof< boost::is_pointer<T>::value, boost::is_array<T>::value, boost::is_const<T>::value, diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_cv.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_cv.hpp index c7b0379..9fbf8b8 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_cv.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_cv.hpp @@ -171,7 +171,7 @@ namespace boost { template<typename T> struct remove_cv { - typedef detail::remove_cv_impl_typeof< + typedef boost::detail::remove_cv_impl_typeof< boost::is_pointer<T>::value, boost::is_array<T>::value, boost::is_const<T>::value, diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_extent.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_extent.hpp index f87ec41..c5a59ef 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_extent.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_extent.hpp @@ -32,7 +32,7 @@ namespace boost { template<typename T> struct remove_extent { - typedef typename detail::remove_extent_impl_typeof< + typedef typename boost::detail::remove_extent_impl_typeof< boost::is_array<T>::value >::template inner<T,remove_extent<T> >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_extent,T) diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_pointer.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_pointer.hpp index 8b9b0d4..ec847f9 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_pointer.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_pointer.hpp @@ -32,7 +32,7 @@ namespace boost { template<typename T> struct remove_pointer { - typedef typename detail::remove_pointer_impl_typeof< + typedef typename boost::detail::remove_pointer_impl_typeof< boost::is_pointer<T>::value >::template inner<T,remove_pointer<T> >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_pointer,T) diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_reference.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_reference.hpp index 367d352..f8a77d4 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_reference.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_reference.hpp @@ -32,7 +32,7 @@ namespace boost { template<typename T> struct remove_reference { - typedef typename detail::remove_reference_impl_typeof< + typedef typename boost::detail::remove_reference_impl_typeof< boost::is_reference<T>::value >::template inner<T,remove_reference<T> >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_reference,T) diff --git a/3rdParty/Boost/src/boost/type_traits/msvc/remove_volatile.hpp b/3rdParty/Boost/src/boost/type_traits/msvc/remove_volatile.hpp index 3759f2a..6f9259c 100644 --- a/3rdParty/Boost/src/boost/type_traits/msvc/remove_volatile.hpp +++ b/3rdParty/Boost/src/boost/type_traits/msvc/remove_volatile.hpp @@ -124,7 +124,7 @@ namespace boost { template<typename T> struct remove_volatile { - typedef detail::remove_volatile_impl_typeof< + typedef boost::detail::remove_volatile_impl_typeof< boost::is_pointer<T>::value, boost::is_array<T>::value, boost::is_const<T>::value, diff --git a/3rdParty/Boost/src/boost/type_traits/remove_const.hpp b/3rdParty/Boost/src/boost/type_traits/remove_const.hpp index 7e18d88..f4d1739 100644 --- a/3rdParty/Boost/src/boost/type_traits/remove_const.hpp +++ b/3rdParty/Boost/src/boost/type_traits/remove_const.hpp @@ -54,6 +54,18 @@ struct remove_const_impl >::type type; }; +#ifndef BOOST_NO_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template <typename T> +struct remove_const_impl<T&&> +{ + typedef T&& type; +}; +#endif + } // namespace detail // * convert a type T to non-const type - remove_const<T> diff --git a/3rdParty/Boost/src/boost/type_traits/remove_cv.hpp b/3rdParty/Boost/src/boost/type_traits/remove_cv.hpp index 09f8ff1..668e755 100644 --- a/3rdParty/Boost/src/boost/type_traits/remove_cv.hpp +++ b/3rdParty/Boost/src/boost/type_traits/remove_cv.hpp @@ -27,10 +27,32 @@ namespace boost { +namespace detail{ + +template <class T> +struct rvalue_ref_filter_rem_cv +{ + typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type; +}; + +#ifndef BOOST_NO_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template <class T> +struct rvalue_ref_filter_rem_cv<T&&> +{ + typedef T&& type; +}; +#endif + +} + #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // convert a type T to a non-cv-qualified type - remove_cv<T> -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename boost::detail::cv_traits_imp<T*>::unqualified_type) +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename boost::detail::rvalue_ref_filter_rem_cv<T>::type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_cv,T&,T&) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const[N],T type[N]) diff --git a/3rdParty/Boost/src/boost/type_traits/remove_reference.hpp b/3rdParty/Boost/src/boost/type_traits/remove_reference.hpp index 8fddc46..a87db33 100644 --- a/3rdParty/Boost/src/boost/type_traits/remove_reference.hpp +++ b/3rdParty/Boost/src/boost/type_traits/remove_reference.hpp @@ -24,7 +24,27 @@ namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,T) +namespace detail{ +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template <class T> +struct remove_rvalue_ref +{ + typedef T type; +}; +#ifndef BOOST_NO_RVALUE_REFERENCES +template <class T> +struct remove_rvalue_ref<T&&> +{ + typedef T type; +}; +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename boost::detail::remove_rvalue_ref<T>::type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T&,T) #if defined(BOOST_ILLEGAL_CV_REFERENCES) diff --git a/3rdParty/Boost/src/boost/type_traits/remove_volatile.hpp b/3rdParty/Boost/src/boost/type_traits/remove_volatile.hpp index 723ebe3..073a2a3 100644 --- a/3rdParty/Boost/src/boost/type_traits/remove_volatile.hpp +++ b/3rdParty/Boost/src/boost/type_traits/remove_volatile.hpp @@ -53,6 +53,17 @@ struct remove_volatile_impl >::type type; }; +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +#ifndef BOOST_NO_RVALUE_REFERENCES +template <typename T> +struct remove_volatile_impl<T&&> +{ + typedef T&& type; +}; +#endif } // namespace detail // * convert a type T to a non-volatile type - remove_volatile<T> diff --git a/3rdParty/Boost/src/boost/type_traits/type_with_alignment.hpp b/3rdParty/Boost/src/boost/type_traits/type_with_alignment.hpp index d790ee1..ac31055 100644 --- a/3rdParty/Boost/src/boost/type_traits/type_with_alignment.hpp +++ b/3rdParty/Boost/src/boost/type_traits/type_with_alignment.hpp @@ -286,43 +286,43 @@ struct __declspec(align(128)) a128 { template<> class type_with_alignment<8> { typedef mpl::if_c< - ::boost::alignment_of<detail::max_align>::value < 8, + ::boost::alignment_of<boost::detail::max_align>::value < 8, align::a8, - detail::type_with_alignment_imp<8> >::type t1; + boost::detail::type_with_alignment_imp<8> >::type t1; public: typedef t1::type type; }; template<> class type_with_alignment<16> { typedef mpl::if_c< - ::boost::alignment_of<detail::max_align>::value < 16, + ::boost::alignment_of<boost::detail::max_align>::value < 16, align::a16, - detail::type_with_alignment_imp<16> >::type t1; + boost::detail::type_with_alignment_imp<16> >::type t1; public: typedef t1::type type; }; template<> class type_with_alignment<32> { typedef mpl::if_c< - ::boost::alignment_of<detail::max_align>::value < 32, + ::boost::alignment_of<boost::detail::max_align>::value < 32, align::a32, - detail::type_with_alignment_imp<32> >::type t1; + boost::detail::type_with_alignment_imp<32> >::type t1; public: typedef t1::type type; }; template<> class type_with_alignment<64> { typedef mpl::if_c< - ::boost::alignment_of<detail::max_align>::value < 64, + ::boost::alignment_of<boost::detail::max_align>::value < 64, align::a64, - detail::type_with_alignment_imp<64> >::type t1; + boost::detail::type_with_alignment_imp<64> >::type t1; public: typedef t1::type type; }; template<> class type_with_alignment<128> { typedef mpl::if_c< - ::boost::alignment_of<detail::max_align>::value < 128, + ::boost::alignment_of<boost::detail::max_align>::value < 128, align::a128, - detail::type_with_alignment_imp<128> >::type t1; + boost::detail::type_with_alignment_imp<128> >::type t1; public: typedef t1::type type; }; |