Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/variant/detail')
21 files changed, 125 insertions, 593 deletions
diff --git a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp index f1c1fb6..5cc9430 100644 --- a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp @@ -49,13 +49,13 @@ private: // representation Visitor& visitor_; Value1& value1_; public: // structors - apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) + apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT : visitor_(visitor) , value1_(value1) { } public: // visitor interfaces @@ -84,13 +84,13 @@ private: // representation Visitor& visitor_; Visitable2& visitable2_; public: // structors - apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) + apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT : visitor_(visitor) , visitable2_(visitable2) { } public: // visitor interfaces @@ -153,14 +153,12 @@ apply_visitor( #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE // // const-visitor version: // -#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - template <typename Visitor, typename Visitable1, typename Visitable2> inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( typename Visitor::result_type ) apply_visitor( @@ -172,11 +170,9 @@ apply_visitor( const Visitor, Visitable2 > unwrapper(visitor, visitable2); return boost::apply_visitor(unwrapper, visitable1); } -#endif // MSVC7 and below exclusion - } // namespace boost #endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp index 5f5642b..034b39b 100644 --- a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp @@ -46,13 +46,13 @@ public: // visitor typedefs private: // representation Visitor& visitor_; public: // structors - explicit apply_visitor_delayed_t(Visitor& visitor) + explicit apply_visitor_delayed_t(Visitor& visitor) BOOST_NOEXCEPT : visitor_(visitor) { } public: // unary visitor interface diff --git a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp index 64199d8..5c28d32 100644 --- a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp @@ -63,21 +63,17 @@ apply_visitor(Visitor& visitor, Visitable& visitable) #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE // // const-visitor version: // -#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - template <typename Visitor, typename Visitable> inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) apply_visitor(const Visitor& visitor, Visitable& visitable) { return visitable.apply_visitor(visitor); } -#endif // MSVC7 and below exclusion - } // namespace boost #endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp b/3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp index ed112b8..1ccf160 100644 --- a/3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp @@ -10,12 +10,13 @@ // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP #define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP +#include "boost/config.hpp" #include "boost/assert.hpp" namespace boost { namespace detail { namespace variant { template <typename T> @@ -24,18 +25,18 @@ class backup_holder private: // representation T* backup_; public: // structors - ~backup_holder() + ~backup_holder() BOOST_NOEXCEPT { delete backup_; } - explicit backup_holder(T* backup) + explicit backup_holder(T* backup) BOOST_NOEXCEPT : backup_(backup) { } backup_holder(const backup_holder&); @@ -50,27 +51,27 @@ public: // modifiers backup_holder& operator=(const T& rhs) { *backup_ = rhs; return *this; } - void swap(backup_holder& rhs) + void swap(backup_holder& rhs) BOOST_NOEXCEPT { T* tmp = rhs.backup_; rhs.backup_ = this->backup_; this->backup_ = tmp; } public: // queries - T& get() + T& get() BOOST_NOEXCEPT { return *backup_; } - const T& get() const + const T& get() const BOOST_NOEXCEPT { return *backup_; } }; @@ -80,13 +81,13 @@ backup_holder<T>::backup_holder(const backup_holder&) { // not intended for copy, but do not want to prohibit syntactically BOOST_ASSERT(false); } template <typename T> -void swap(backup_holder<T>& lhs, backup_holder<T>& rhs) +void swap(backup_holder<T>& lhs, backup_holder<T>& rhs) BOOST_NOEXCEPT { lhs.swap(rhs); } }} // namespace detail::variant } // namespace boost diff --git a/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp b/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp deleted file mode 100644 index 823a79a..0000000 --- a/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp +++ /dev/null @@ -1,30 +0,0 @@ -//----------------------------------------------------------------------------- -// boost/variant/detail/bool_trait_def.hpp header file -// See http://www.boost.org for updates, documentation, and revision history. -//----------------------------------------------------------------------------- -// -// Copyright (c) 2003 -// Eric Friedman -// -// 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) - -// Needed until move-related traits incorporated into type_traits library. -// no include guards, the header is intended for multiple inclusion! - -// should be the last #include -#include "boost/type_traits/detail/bool_trait_def.hpp" - -#define BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \ -template< typename T > struct trait \ - BOOST_TT_AUX_BOOL_C_BASE(C) \ -{ \ - BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ - BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ -}; \ -/**/ - -#define BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(arity, name) \ -BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(arity, name) \ -/**/ diff --git a/3rdParty/Boost/src/boost/variant/detail/bool_trait_undef.hpp b/3rdParty/Boost/src/boost/variant/detail/bool_trait_undef.hpp deleted file mode 100644 index 9b8fb54..0000000 --- a/3rdParty/Boost/src/boost/variant/detail/bool_trait_undef.hpp +++ /dev/null @@ -1,21 +0,0 @@ -//----------------------------------------------------------------------------- -// boost/variant/detail/bool_trait_undef.hpp header file -// See http://www.boost.org for updates, documentation, and revision history. -//----------------------------------------------------------------------------- -// -// Copyright (c) 2003 -// Eric Friedman -// -// 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) - -// Needed until move-related traits incorporated into type_traits library. -// no include guards, the header is intended for multiple inclusion! - -// should be the last #include -#include "boost/type_traits/detail/bool_trait_undef.hpp" - - -#undef BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1 -#undef BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX diff --git a/3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp b/3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp index f23f174..24feed6 100644 --- a/3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp @@ -22,25 +22,19 @@ namespace detail { namespace variant { // (detail) function template cast_storage // // Casts the given storage to the specified type, but with qualification. // template <typename T> -inline T& cast_storage( - void* storage - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) - ) +inline T& cast_storage(void* storage) { return *static_cast<T*>(storage); } template <typename T> -inline const T& cast_storage( - const void* storage - BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) - ) +inline const T& cast_storage(const void* storage) { return *static_cast<const T*>(storage); } }} // namespace detail::variant } // namespace boost diff --git a/3rdParty/Boost/src/boost/variant/detail/config.hpp b/3rdParty/Boost/src/boost/variant/detail/config.hpp index eb18201..84564a4 100644 --- a/3rdParty/Boost/src/boost/variant/detail/config.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/config.hpp @@ -18,13 +18,12 @@ /////////////////////////////////////////////////////////////////////////////// // macro BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING // #if BOOST_WORKAROUND(__MWERKS__, <= 0x3201) \ || BOOST_WORKAROUND(BOOST_INTEL, <= 700) \ - || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ && !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) # define BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING #endif /////////////////////////////////////////////////////////////////////////////// // macro BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND diff --git a/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp b/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp index 76bd7c7..a974b4f 100644 --- a/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp @@ -75,13 +75,12 @@ public: /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction enable_recursive // // See boost/variant/detail/enable_recursive_fwd.hpp for more information. // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T, typename RecursiveVariant, typename NoWrapper> struct enable_recursive : BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL( T, RecursiveVariant, ::boost::recursive_variant_ ) @@ -109,40 +108,12 @@ public: // metafunction result , t_ , boost::recursive_wrapper<t_> >::type type; }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -template <typename T, typename RecursiveVariant, typename NoWrapper> -struct enable_recursive -{ -private: // helpers, for metafunction result (below) - - typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL( - T, RecursiveVariant, ::boost::recursive_variant_ - )::type t_; - -public: // metafunction result - - // [Wrap with recursive_wrapper only if rebind really changed something:] - typedef typename mpl::if_< - mpl::or_< - NoWrapper - , is_same< t_,T > - , is_reference<t_> - , is_pointer<t_> - > - , t_ - , boost::recursive_wrapper<t_> - >::type type; - -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction class quoted_enable_recursive // // Same behavior as enable_recursive metafunction (see above). // diff --git a/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp b/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp index 3336c1f..39a6b71 100644 --- a/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp @@ -14,57 +14,37 @@ #define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP #include "boost/mpl/aux_/config/ctps.hpp" #include "boost/mpl/bool_fwd.hpp" -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include "boost/mpl/bool.hpp" -#else -# include "boost/type_traits/is_base_and_derived.hpp" -#endif namespace boost { namespace detail { namespace variant { /////////////////////////////////////////////////////////////////////////////// // (detail) tag recursive_flag // // Signifies that the variant should perform recursive substituion. // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct recursive_flag { typedef T type; }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -struct recursive_flag_tag -{ -}; - -template <typename T> -struct recursive_flag - : recursive_flag_tag -{ - typedef T type; -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction is_recursive_flag // // Signifies that the variant should perform recursive substituion. // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct is_recursive_flag : mpl::false_ { }; @@ -72,21 +52,12 @@ struct is_recursive_flag template <typename T> struct is_recursive_flag< recursive_flag<T> > : mpl::true_ { }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -template <typename T> -struct is_recursive_flag - : is_base_and_derived< recursive_flag_tag,T > -{ -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction enable_recursive // // Attempts recursive_variant_ tag substitution, wrapping with // boost::recursive_wrapper if substituion occurs w/ non-indirect result diff --git a/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp b/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp index cc1f25b..522b796 100644 --- a/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp @@ -14,45 +14,39 @@ #define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP #include "boost/config.hpp" #include "boost/variant/detail/generic_result_type.hpp" #include "boost/assert.hpp" -#if !defined(BOOST_MSVC) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -# include "boost/type_traits/remove_reference.hpp" -#endif - namespace boost { namespace detail { namespace variant { /////////////////////////////////////////////////////////////////////////////// // (detail) function template forced_return // // Logical error to permit invocation at runtime, but (artificially) satisfies // compile-time requirement of returning a result value. // #if !defined(BOOST_MSVC) \ - && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_NO_VOID_RETURNS) // "standard" implementation: template <typename T> -inline T forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) ) +inline T forced_return() { // logical error: should never be here! (see above) BOOST_ASSERT(false); - typedef typename boost::remove_reference<T>::type basic_type; - basic_type* dummy = 0; - return *static_cast< basic_type* >(dummy); + T (*dummy_function_ptr)() = 0; + return dummy_function_ptr(); } template <> -inline void forced_return<void>( BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(void) ) +inline void forced_return<void>() { // logical error: should never be here! (see above) BOOST_ASSERT(false); } #elif !defined(BOOST_MSVC) @@ -63,42 +57,46 @@ inline void forced_return<void>( BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(void) ) // throwing? by recursive call to forced_return itself? etc. // template <typename T> inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) -forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) ) +forced_return() { // logical error: should never be here! (see above) BOOST_ASSERT(false); BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) (*dummy)() = 0; return dummy(); } #else // defined(BOOST_MSVC) +# pragma warning( push ) +# pragma warning( disable : 4702 ) // unreachable code // msvc-specific implementation // // Leverages __declspec(noreturn) for optimized implementation. // __declspec(noreturn) inline void forced_return_no_return() {}; template <typename T> inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) -forced_return( BOOST_EXPLICIT_TEMPLATE_TYPE(T) ) +forced_return() { // logical error: should never be here! (see above) BOOST_ASSERT(false); forced_return_no_return(); } +# pragma warning( pop ) + #endif // BOOST_MSVC optimization }} // namespace detail::variant } // namespace boost #endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/has_nothrow_move.hpp b/3rdParty/Boost/src/boost/variant/detail/has_nothrow_move.hpp deleted file mode 100644 index 51ca095..0000000 --- a/3rdParty/Boost/src/boost/variant/detail/has_nothrow_move.hpp +++ /dev/null @@ -1,106 +0,0 @@ - -// (C) Copyright Eric Friedman 2002-2003. -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org for most recent version including documentation. - -#ifndef BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED -#define BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED - -#include "boost/config.hpp" // for STATIC_CONSTANT -#include "boost/variant/detail/has_trivial_move.hpp" -#include "boost/type_traits/has_nothrow_copy.hpp" -#include "boost/type_traits/has_nothrow_assign.hpp" - -#include "boost/mpl/and.hpp" -#include "boost/mpl/or.hpp" - -// should be the last #include -#include "boost/variant/detail/bool_trait_def.hpp" - -namespace boost { -namespace detail { namespace variant { - -// TRAIT: has_nothrow_move - -template <typename T> -struct has_nothrow_move_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::or_< - has_trivial_move<T> - , ::boost::mpl::and_< - has_nothrow_copy<T> - , has_nothrow_assign<T> - > - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_nothrow_move - , T - , (::boost::detail::variant::has_nothrow_move_impl<T>::value) - ) - - -// TRAIT: has_nothrow_move_constructor - -template <typename T> -struct has_nothrow_move_constructor_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::or_< - has_nothrow_move<T> - , has_trivial_move_constructor<T> - , has_nothrow_copy<T> - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_nothrow_move_constructor - , T - , (::boost::detail::variant::has_nothrow_move_constructor_impl<T>::value) - ) - - -// TRAIT: has_nothrow_move_assign - -template <typename T> -struct has_nothrow_move_assign_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::or_< - has_nothrow_move<T> - , has_trivial_move_assign<T> - , has_nothrow_assign<T> - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_nothrow_move_assign - , T - , (::boost::detail::variant::has_nothrow_move_assign_impl<T>::value) - ) - -}} // namespace detail::variant - -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move) -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move_constructor) -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_nothrow_move_assign) - -} // namespace boost - -#include "boost/variant/detail/bool_trait_undef.hpp" - -#endif // BOOST_VARIANT_DETAIL_HAS_NOTHROW_MOVE_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/variant/detail/has_trivial_move.hpp b/3rdParty/Boost/src/boost/variant/detail/has_trivial_move.hpp deleted file mode 100644 index 5293366..0000000 --- a/3rdParty/Boost/src/boost/variant/detail/has_trivial_move.hpp +++ /dev/null @@ -1,100 +0,0 @@ - -// (C) Copyright Eric Friedman 2002-2003. -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org for most recent version including documentation. - -#ifndef BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED -#define BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED - -#include "boost/config.hpp" // for STATIC_CONSTANT -#include "boost/type_traits/has_trivial_copy.hpp" -#include "boost/type_traits/has_trivial_assign.hpp" - -#include "boost/mpl/and.hpp" -#include "boost/mpl/or.hpp" - -// should be the last #include -#include "boost/variant/detail/bool_trait_def.hpp" - -namespace boost { -namespace detail { namespace variant { - -// TRAIT: has_trivial_move - -template <typename T> -struct has_trivial_move_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::and_< - has_trivial_copy<T> - , has_trivial_assign<T> - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_trivial_move - , T - , (::boost::detail::variant::has_trivial_move_impl<T>::value) - ) - - -// TRAIT: has_trivial_move_constructor - -template <typename T> -struct has_trivial_move_constructor_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::or_< - has_trivial_move<T> - , has_trivial_copy<T> - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_trivial_move_constructor - , T - , (::boost::detail::variant::has_trivial_move_constructor_impl<T>::value) - ) - - -// TRAIT: has_trivial_move_assign - -template <typename T> -struct has_trivial_move_assign_impl -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - ::boost::mpl::or_< - has_trivial_move<T> - , has_trivial_assign<T> - >::type::value - ) - ); -}; - -BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1( - has_trivial_move_assign - , T - , (::boost::detail::variant::has_trivial_move_assign_impl<T>::value) - ) - -}} // namespace detail::variant - -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move) -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move_constructor) -BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(1,::boost::detail::variant::has_trivial_move_assign) - -} // namespace boost - -#include "boost/variant/detail/bool_trait_undef.hpp" - -#endif // BOOST_VARIANT_DETAIL_HAS_TRIVIAL_MOVE_HPP_INCLUDED diff --git a/3rdParty/Boost/src/boost/variant/detail/hash_variant.hpp b/3rdParty/Boost/src/boost/variant/detail/hash_variant.hpp index 3da669e..958662e 100644 --- a/3rdParty/Boost/src/boost/variant/detail/hash_variant.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/hash_variant.hpp @@ -11,13 +11,13 @@ // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_HASH_VARIANT_FUNCTION_HPP #define BOOST_HASH_VARIANT_FUNCTION_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #include <boost/variant/variant_fwd.hpp> #include <boost/variant/static_visitor.hpp> #include <boost/variant/apply_visitor.hpp> @@ -26,14 +26,13 @@ namespace boost { namespace detail { namespace variant { struct variant_hasher: public boost::static_visitor<std::size_t> { template <class T> std::size_t operator()(T const& val) const { - using namespace boost; - hash<T> hasher; + boost::hash<T> hasher; return hasher(val); } }; }} template < BOOST_VARIANT_ENUM_PARAMS(typename T) > diff --git a/3rdParty/Boost/src/boost/variant/detail/initializer.hpp b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp index b14d6c8..f6f425e 100644 --- a/3rdParty/Boost/src/boost/variant/detail/initializer.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp @@ -17,12 +17,13 @@ #include "boost/config.hpp" #include "boost/call_traits.hpp" #include "boost/detail/reference_content.hpp" #include "boost/variant/recursive_wrapper_fwd.hpp" +#include "boost/variant/detail/move.hpp" #if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) # include "boost/mpl/aux_/value_wknd.hpp" # include "boost/mpl/int.hpp" # include "boost/mpl/iter_fold.hpp" # include "boost/mpl/next.hpp" @@ -76,14 +77,28 @@ struct make_initializer_node private: // helpers, for static functions (below) typedef typename mpl::deref<Iterator>::type recursive_enabled_T; typedef typename unwrap_recursive<recursive_enabled_T>::type public_T; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + typedef boost::is_reference<public_T> + is_reference_content_t; + + typedef typename boost::mpl::if_<is_reference_content_t, public_T, const public_T& >::type + param_T; + + template <class T> struct disable_overload{}; + + typedef typename boost::mpl::if_<is_reference_content_t, disable_overload<public_T>, public_T&& >::type + param2_T; +#else typedef typename call_traits<public_T>::param_type param_T; +#endif public: // static functions using base::initialize; static int initialize(void* dest, param_T operand) @@ -93,12 +108,24 @@ struct make_initializer_node >::type internal_T; new(dest) internal_T(operand); return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which } +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + static int initialize(void* dest, param2_T operand) + { + // This assert must newer trigger, because all the reference contents are + // handled by the initilize(void* dest, param_T operand) function above + BOOST_ASSERT(!is_reference_content_t::value); + + typedef typename boost::mpl::if_<is_reference_content_t, param2_T, recursive_enabled_T>::type value_T; + new(dest) value_T( boost::detail::variant::move(operand) ); + return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which + } +#endif }; friend class initializer_node; public: // metafunction result @@ -122,46 +149,39 @@ public: // static functions static void initialize(); }; #else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) -# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - + // Obsolete. Remove. #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \ BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \ /**/ + // Obsolete. Remove. #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ typedef typename unwrap_recursive< \ BOOST_PP_CAT(recursive_enabled_T,N) \ >::type BOOST_PP_CAT(public_T,N); \ typedef typename call_traits< \ BOOST_PP_CAT(public_T,N) \ >::param_type BOOST_PP_CAT(param_T,N); \ /**/ -# else // MSVC7 and below - - #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \ - BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \ - , BOOST_VARIANT_ENUM_PARAMS(typename param_T) \ - /**/ - - #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ - /**/ - -# endif // MSVC7 and below workaround - -template < BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS > +template < BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) > struct preprocessor_list_initializer { public: // static functions #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \ - BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ + typedef typename unwrap_recursive< \ + BOOST_PP_CAT(recursive_enabled_T,N) \ + >::type BOOST_PP_CAT(public_T,N); \ + typedef typename call_traits< \ + BOOST_PP_CAT(public_T,N) \ + >::param_type BOOST_PP_CAT(param_T,N); \ static int initialize( \ void* dest \ , BOOST_PP_CAT(param_T,N) operand \ ) \ { \ typedef typename boost::detail::make_reference_content< \ @@ -180,28 +200,12 @@ public: // static functions ) #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION }; -# if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) - -#if !defined(BOOST_VARIANT_AUX_ECHO) -# define BOOST_VARIANT_AUX_ECHO(z,N,token) token -#endif - -template <> -struct preprocessor_list_initializer< - BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, int) - , BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, const int) - > -{ -}; - -# endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround - #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround }} // namespace detail::variant } // namespace boost /////////////////////////////////////////////////////////////////////////////// @@ -226,40 +230,20 @@ struct preprocessor_list_initializer< > \ >::type::first \ /**/ #else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) -# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - + // Obsolete. Remove. #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ BOOST_VARIANT_ENUM_PARAMS(typename_base) \ /**/ -# else // MSVC7 and below - - #define BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE(z,N,T) \ - ::boost::call_traits< \ - ::boost::unwrap_recursive<BOOST_PP_CAT(T,N)>::type \ - >::param_type \ - /**/ - - #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ - BOOST_VARIANT_ENUM_PARAMS(typename_base) \ - , BOOST_PP_ENUM( \ - BOOST_VARIANT_LIMIT_TYPES \ - , BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE \ - , typename_base \ - ) \ - /**/ - -# endif // MSVC7 workaround - #define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \ ::boost::detail::variant::preprocessor_list_initializer< \ - BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ + BOOST_VARIANT_ENUM_PARAMS(typename_base) \ > \ /**/ #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround #endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp b/3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp index b2c74ad..37d725c 100644 --- a/3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp @@ -1,13 +1,13 @@ //----------------------------------------------------------------------------- // boost variant/detail/make_variant_list.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // -// Copyright (c) 2002-2003 -// Eric Friedman, Itay Maman +// Copyright (c) 2002-2003 Eric Friedman, Itay Maman +// Copyright (c) 2013 Antony Polukhin // // 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) #ifndef BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP @@ -28,12 +28,23 @@ namespace detail { namespace variant { // Provides a MPL-compatible sequence with the specified non-void types // as arguments. // // Rationale: see class template convert_void (variant_fwd.hpp) and using- // declaration workaround (below). // + +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) + +template < typename... T > +struct make_variant_list +{ + typedef typename mpl::list< T... >::type type; +}; + +#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) + template < BOOST_VARIANT_ENUM_PARAMS(typename T) > struct make_variant_list { public: // metafunction result // [Define a macro to convert any void(NN) tags to mpl::void...] @@ -51,10 +62,12 @@ public: // metafunction result // [...and, finally, the conversion macro can be undefined:] # undef BOOST_VARIANT_AUX_CONVERT_VOID }; +#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround + }} // namespace detail::variant } // namespace boost #endif // BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/move.hpp b/3rdParty/Boost/src/boost/variant/detail/move.hpp index 572cfbb..24f8310 100644 --- a/3rdParty/Boost/src/boost/variant/detail/move.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/move.hpp @@ -2,12 +2,13 @@ // boost variant/detail/move.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2002-2003 Eric Friedman // Copyright (c) 2002 by Andrei Alexandrescu +// Copyright (c) 2013 Antony Polukhin // // 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) // // This file derivative of MoJO. Much thanks to Andrei for his initial work. @@ -21,146 +22,48 @@ #include <iterator> // for iterator_traits #include <new> // for placement new #include "boost/config.hpp" #include "boost/detail/workaround.hpp" -#include "boost/mpl/if.hpp" -#include "boost/type_traits/is_base_and_derived.hpp" +#include "boost/move/move.hpp" -namespace boost { -namespace detail { namespace variant { +namespace boost { namespace detail { namespace variant { -////////////////////////////////////////////////////////////////////////// -// forward declares -// -// NOTE: Incomplete until (if?) Boost.Move becomes part of Boost. -// -template <typename Deriving> class moveable; -template <typename T> class move_source; -template <typename T> class move_return; - -namespace detail { - -// (detail) moveable_tag -// -// Concrete type from which moveable<T> derives. -// -// TODO: Move into moveable_fwd.hpp and define has_move_constructor. -// -template <typename Deriving> -struct moveable_tag -{ -}; - -} // namespace detail - -////////////////////////////////////////////////////////////////////////// -// function template move -// -// Takes a T& and returns, if T derives moveable<T>, a move_source<T> for -// the object; else, returns the T&. -// - -namespace detail { - -// (detail) class template move_type -// -// Metafunction that, given moveable T, provides move_source<T>, else T&. -// -template <typename T> -struct move_type -{ -public: // metafunction result - - typedef typename mpl::if_< - is_base_and_derived<detail::moveable_tag<T>, T> - , move_source<T> - , T& - >::type type; - -}; - -} // namespace detail - -template <typename T> -inline - typename detail::move_type<T>::type -move(T& source) -{ - typedef typename detail::move_type<T>::type - move_t; - - return move_t(source); -} - -////////////////////////////////////////////////////////////////////////// -// class template return_t -// -// Metafunction that, given moveable T, provides move_return<T>, else T. -// -template <typename T> -struct return_t -{ -public: // metafunction result - - typedef typename mpl::if_< - is_base_and_derived<moveable<T>, T> - , move_return<T> - , T - >::type type; - -}; +using boost::move; ////////////////////////////////////////////////////////////////////////// // function template move_swap // // Swaps using Koenig lookup but falls back to move-swap for primitive // types and on non-conforming compilers. // -#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) \ - || BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(2)) - -// [Indicate that move_swap by overload is disabled...] -#define BOOST_NO_MOVE_SWAP_BY_OVERLOAD +namespace move_swap_fallback { -// [...and provide straight swap-by-move implementation:] -template <typename T> -inline void move_swap(T& lhs, T& rhs) -{ - T tmp( boost::detail::variant::move(lhs) ); - lhs = boost::detail::variant::move(rhs); - rhs = boost::detail::variant::move(tmp); -} - -#else// !workaround - -namespace detail { namespace move_swap { - -template <typename T> -inline void swap(T& lhs, T& rhs) +template <typename T1, typename T2> +inline void swap(T1& lhs, T2& rhs) { - T tmp( boost::detail::variant::move(lhs) ); + T1 tmp( boost::detail::variant::move(lhs) ); lhs = boost::detail::variant::move(rhs); rhs = boost::detail::variant::move(tmp); } -}} // namespace detail::move_swap +} // namespace move_swap_fallback template <typename T> inline void move_swap(T& lhs, T& rhs) { - using detail::move_swap::swap; - +#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) + move_swap_fallback::swap(lhs, rhs); +#else + using move_swap_fallback::swap; swap(lhs, rhs); +#endif } -#endif // workaround - -}} // namespace detail::variant -} // namespace boost +}}} // namespace boost::detail::variant #endif // BOOST_VARIANT_DETAIL_MOVE_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp b/3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp index bdd69ad..ff20a01 100644 --- a/3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp @@ -13,18 +13,12 @@ // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP #define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP #include "boost/mpl/aux_/config/ctps.hpp" -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -# include "boost/mpl/eval_if.hpp" -# include "boost/mpl/bool.hpp" -# include "boost/mpl/identity.hpp" -# include "boost/type.hpp" -#endif namespace boost { namespace detail { namespace variant { /////////////////////////////////////////////////////////////////////////////// @@ -41,13 +35,12 @@ struct over_sequence /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction is_over_sequence (modeled on code by David Abrahams) // // Indicates whether the specified type is of form over_sequence<...> or not. // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct is_over_sequence : mpl::false_ { }; @@ -55,41 +48,11 @@ struct is_over_sequence template <typename Types> struct is_over_sequence< over_sequence<Types> > : mpl::true_ { }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -typedef char (&yes_over_sequence_t)[1]; -typedef char (&no_over_sequence_t)[2]; - -no_over_sequence_t is_over_sequence_test(...); - -template<typename T> -yes_over_sequence_t is_over_sequence_test( - type< ::boost::detail::variant::over_sequence<T> > - ); - -template<typename T> -struct is_over_sequence_impl -{ - BOOST_STATIC_CONSTANT(bool, value = ( - sizeof(is_over_sequence_test(type<T>())) - == sizeof(yes_over_sequence_t) - )); -}; - -template <typename T> -struct is_over_sequence - : mpl::bool_< - ::boost::detail::variant::is_over_sequence_impl<T>::value - > -{ -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround }} // namespace detail::variant } // namespace boost #endif // BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/substitute.hpp b/3rdParty/Boost/src/boost/variant/detail/substitute.hpp index 97fe205..56faa89 100644 --- a/3rdParty/Boost/src/boost/variant/detail/substitute.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/substitute.hpp @@ -122,12 +122,33 @@ struct substitute< }; // // template expression (i.e., F<...>) specializations // +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) +template < + template <typename...> class F + , typename... Ts + , typename Dest + , typename Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) + > +struct substitute< + F<Ts...> + , Dest + , Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity) + > +{ + typedef F<typename substitute< + Ts, Dest, Source + >::type...> type; +}; +#endif // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) + #define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \ typedef typename substitute< \ BOOST_PP_CAT(U,N), Dest, Source \ >::type BOOST_PP_CAT(u,N); \ /**/ diff --git a/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp b/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp index 1723847..8084cb8 100644 --- a/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp @@ -25,13 +25,12 @@ // #include "boost/mpl/aux_/config/ctps.hpp" #include "boost/mpl/aux_/config/ttp.hpp" #if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ - || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) # define BOOST_VARIANT_DETAIL_NO_SUBSTITUTE #endif namespace boost { namespace detail { namespace variant { diff --git a/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp b/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp index 9cc3015..96bc274 100644 --- a/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp +++ b/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp @@ -17,26 +17,25 @@ #include "boost/variant/detail/backup_holder.hpp" #include "boost/variant/detail/cast_storage.hpp" #include "boost/variant/detail/forced_return.hpp" #include "boost/variant/detail/generic_result_type.hpp" -#include "boost/assert.hpp" #include "boost/mpl/eval_if.hpp" #include "boost/mpl/bool.hpp" #include "boost/mpl/identity.hpp" #include "boost/mpl/int.hpp" #include "boost/mpl/next.hpp" #include "boost/mpl/deref.hpp" #include "boost/mpl/or.hpp" #include "boost/preprocessor/cat.hpp" #include "boost/preprocessor/inc.hpp" #include "boost/preprocessor/repeat.hpp" #include "boost/type_traits/is_same.hpp" #include "boost/type_traits/has_nothrow_copy.hpp" -#include "boost/variant/detail/has_nothrow_move.hpp" +#include "boost/type_traits/is_nothrow_move_constructible.hpp" #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) # pragma warning (push) # pragma warning (disable : 4702) //unreachable code #endif @@ -44,16 +43,24 @@ // BOOST_VARIANT_VISITATION_UNROLLING_LIMIT // // Unrolls variant's visitation mechanism to reduce template instantiation // and potentially increase runtime performance. (TODO: Investigate further.) // #if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT) + +#ifndef BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES +# include "boost/mpl/limits/list.hpp" +# define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT \ + BOOST_MPL_LIMIT_LIST_SIZE +#else # define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT \ BOOST_VARIANT_LIMIT_TYPES #endif +#endif + namespace boost { namespace detail { namespace variant { /////////////////////////////////////////////////////////////////////////////// // (detail) class apply_visitor_unrolled // @@ -64,13 +71,12 @@ struct apply_visitor_unrolled {}; /////////////////////////////////////////////////////////////////////////////// // (detail) class template visitation_impl_step // // "Never ending" iterator range facilitates visitation_impl unrolling. // -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename Iter, typename LastIter> struct visitation_impl_step { typedef typename mpl::deref<Iter>::type type; @@ -84,35 +90,12 @@ template <typename LastIter> struct visitation_impl_step< LastIter,LastIter > { typedef apply_visitor_unrolled type; typedef visitation_impl_step next; }; -#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - -template <typename Iter, typename LastIter> -struct visitation_impl_step -{ - typedef typename mpl::eval_if< - is_same<Iter, LastIter> - , mpl::identity<apply_visitor_unrolled> - , Iter - >::type type; - - typedef typename mpl::eval_if< - is_same<type, apply_visitor_unrolled> //is_same<Iter, LastIter> - , mpl::identity<LastIter> - , mpl::next<Iter> - >::type next_iter; - - typedef visitation_impl_step< - next_iter, LastIter - > next; -}; - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround /////////////////////////////////////////////////////////////////////////////// // (detail) function template visitation_impl_invoke // // Invokes the given visitor on the specified type in the given storage. // @@ -160,13 +143,13 @@ visitation_impl_invoke( , NoBackupFlag , int ) { typedef typename mpl::or_< NoBackupFlag - , has_nothrow_move_constructor<T> + , is_nothrow_move_constructible<T> , has_nothrow_copy<T> >::type never_uses_backup; return (visitation_impl_invoke_impl)( internal_which, visitor, storage, t , never_uses_backup() @@ -175,14 +158,13 @@ visitation_impl_invoke( template <typename Visitor, typename VoidPtrCV, typename NBF> inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long) { - // should never be here at runtime: - BOOST_ASSERT(false); + // should never be here at runtime! typedef typename Visitor::result_type result_type; return ::boost::detail::variant::forced_return< result_type >(); } /////////////////////////////////////////////////////////////////////////////// // (detail) function template visitation_impl @@ -200,14 +182,13 @@ inline visitation_impl( int, int, Visitor&, VPCV , mpl::true_ // is_apply_visitor_unrolled , NBF, W* = 0, S* = 0 ) { - // should never be here at runtime: - BOOST_ASSERT(false); + // should never be here at runtime! typedef typename Visitor::result_type result_type; return ::boost::detail::variant::forced_return< result_type >(); } template < typename Which, typename step0 |