Swiftdiff options
| author | Remko Tronçon <git@el-tramo.be> | 2010-08-08 18:41:53 (GMT) |
|---|---|---|
| committer | Remko Tronçon <git@el-tramo.be> | 2010-08-08 18:41:53 (GMT) |
| commit | 19df82042f44c201e5a2821b4fa35465e33a1c90 (patch) | |
| tree | 1746bddfa31ce2a6488ef5186036a049a255c9da /3rdParty/Boost/src/boost/variant | |
| parent | 4a5a0977f661bf5c7c34ee7aa48b35073a682203 (diff) | |
| download | swift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.zip swift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.tar.bz2 | |
Added XEP-0004 data forms parsing & serializing.
Diffstat (limited to '3rdParty/Boost/src/boost/variant')
32 files changed, 5540 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/variant/apply_visitor.hpp b/3rdParty/Boost/src/boost/variant/apply_visitor.hpp new file mode 100644 index 0000000..53bada0 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/apply_visitor.hpp @@ -0,0 +1,20 @@ +//----------------------------------------------------------------------------- +// boost variant/apply_visitor.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) + +#ifndef BOOST_VARIANT_APPLY_VISITOR_HPP +#define BOOST_VARIANT_APPLY_VISITOR_HPP + +#include "boost/variant/detail/apply_visitor_unary.hpp" +#include "boost/variant/detail/apply_visitor_binary.hpp" +#include "boost/variant/detail/apply_visitor_delayed.hpp" + +#endif // BOOST_VARIANT_APPLY_VISITOR_HPP diff --git a/3rdParty/Boost/src/boost/variant/bad_visit.hpp b/3rdParty/Boost/src/boost/variant/bad_visit.hpp new file mode 100644 index 0000000..ca53940 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/bad_visit.hpp @@ -0,0 +1,41 @@ +//----------------------------------------------------------------------------- +// boost variant/bad_visit.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_BAD_VISIT_HPP +#define BOOST_VARIANT_BAD_VISIT_HPP + +#include <exception> + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// class bad_visit +// +// Exception thrown when a visitation attempt via apply_visitor fails due +// to invalid visited subtype or contents. +// +struct bad_visit + : std::exception +{ +public: // std::exception interface + + virtual const char * what() const throw() + { + return "boost::bad_visit: " + "failed visitation using boost::apply_visitor"; + } + +}; + +} // namespace boost + +#endif // BOOST_VARIANT_BAD_VISIT_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp new file mode 100644 index 0000000..92cdb42 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp @@ -0,0 +1,172 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/apply_visitor_binary.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP +#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP + +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" +#include "boost/variant/detail/generic_result_type.hpp" + +#include "boost/variant/detail/apply_visitor_unary.hpp" + +#include "boost/utility/enable_if.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// function template apply_visitor(visitor, visitable1, visitable2) +// +// Visits visitable1 and visitable2 such that their values (which we +// shall call x and y, respectively) are used as arguments in the +// expression visitor(x, y). +// + +namespace detail { namespace variant { + +template <typename Visitor, typename Value1> +class apply_visitor_binary_invoke +{ +public: // visitor typedefs + + typedef typename Visitor::result_type + result_type; + +private: // representation + + Visitor& visitor_; + Value1& value1_; + +public: // structors + + apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) + : visitor_(visitor) + , value1_(value1) + { + } + +public: // visitor interfaces + + template <typename Value2> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + operator()(Value2& value2) + { + return visitor_(value1_, value2); + } + +}; + +template <typename Visitor, typename Visitable2> +class apply_visitor_binary_unwrap +{ +public: // visitor typedefs + + typedef typename Visitor::result_type + result_type; + +private: // representation + + Visitor& visitor_; + Visitable2& visitable2_; + +public: // structors + + apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) + : visitor_(visitor) + , visitable2_(visitable2) + { + } + +public: // visitor interfaces + + template <typename Value1> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + operator()(Value1& value1) + { + apply_visitor_binary_invoke< + Visitor + , Value1 + > invoker(visitor_, value1); + + return boost::apply_visitor(invoker, visitable2_); + } + +}; + +}} // namespace detail::variant + +// +// nonconst-visitor version: +// + +#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302)) + +# define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \ + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \ + /**/ + +#else // EDG-based compilers + +# define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \ + typename enable_if< \ + mpl::not_< is_const< V > > \ + , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \ + >::type \ + /**/ + +#endif // EDG-based compilers workaround + +template <typename Visitor, typename Visitable1, typename Visitable2> +inline + BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) +apply_visitor( + Visitor& visitor + , Visitable1& visitable1, Visitable2& visitable2 + ) +{ + ::boost::detail::variant::apply_visitor_binary_unwrap< + Visitor, Visitable2 + > unwrapper(visitor, visitable2); + + return boost::apply_visitor(unwrapper, visitable1); +} + +#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( + const Visitor& visitor + , Visitable1& visitable1, Visitable2& visitable2 + ) +{ + ::boost::detail::variant::apply_visitor_binary_unwrap< + 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 new file mode 100644 index 0000000..31c79a2 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp @@ -0,0 +1,85 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/apply_visitor_delayed.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP +#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP + +#include "boost/variant/detail/generic_result_type.hpp" + +#include "boost/variant/detail/apply_visitor_unary.hpp" +#include "boost/variant/detail/apply_visitor_binary.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// function template apply_visitor(visitor) +// +// Returns a function object, overloaded for unary and binary usage, that +// visits its arguments using visitor (or a copy of visitor) via +// * apply_visitor( visitor, [argument] ) +// under unary invocation, or +// * apply_visitor( visitor, [argument1], [argument2] ) +// under binary invocation. +// +// NOTE: Unlike other apply_visitor forms, the visitor object must be +// non-const; this prevents user from giving temporary, to disastrous +// effect (i.e., returned function object would have dead reference). +// + +template <typename Visitor> +class apply_visitor_delayed_t +{ +public: // visitor typedefs + + typedef typename Visitor::result_type + result_type; + +private: // representation + + Visitor& visitor_; + +public: // structors + + explicit apply_visitor_delayed_t(Visitor& visitor) + : visitor_(visitor) + { + } + +public: // unary visitor interface + + template <typename Visitable> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + operator()(Visitable& visitable) + { + return apply_visitor(visitor_, visitable); + } + +public: // binary visitor interface + + template <typename Visitable1, typename Visitable2> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + operator()(Visitable1& visitable1, Visitable2& visitable2) + { + return apply_visitor(visitor_, visitable1, visitable2); + } + +}; + +template <typename Visitor> +inline apply_visitor_delayed_t<Visitor> apply_visitor(Visitor& visitor) +{ + return apply_visitor_delayed_t<Visitor>(visitor); +} + +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp new file mode 100644 index 0000000..10b361a --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp @@ -0,0 +1,79 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/apply_visitor_unary.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP +#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP + +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" +#include "boost/variant/detail/generic_result_type.hpp" + +#include "boost/utility/enable_if.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// function template apply_visitor(visitor, visitable) +// +// Visits visitable with visitor. +// + +// +// nonconst-visitor version: +// + +#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302)) + +# define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \ + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \ + /**/ + +#else // EDG-based compilers + +# define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \ + typename enable_if< \ + mpl::not_< is_const< V > > \ + , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \ + >::type \ + /**/ + +#endif // EDG-based compilers workaround + +template <typename Visitor, typename Visitable> +inline + BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) +apply_visitor(Visitor& visitor, Visitable& visitable) +{ + return visitable.apply_visitor(visitor); +} + +#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 new file mode 100644 index 0000000..ed112b8 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp @@ -0,0 +1,94 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/backup_holder.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) + +#ifndef BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP +#define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP + +#include "boost/assert.hpp" + +namespace boost { +namespace detail { namespace variant { + +template <typename T> +class backup_holder +{ +private: // representation + + T* backup_; + +public: // structors + + ~backup_holder() + { + delete backup_; + } + + explicit backup_holder(T* backup) + : backup_(backup) + { + } + + backup_holder(const backup_holder&); + +public: // modifiers + + backup_holder& operator=(const backup_holder& rhs) + { + *backup_ = rhs.get(); + return *this; + } + + backup_holder& operator=(const T& rhs) + { + *backup_ = rhs; + return *this; + } + + void swap(backup_holder& rhs) + { + T* tmp = rhs.backup_; + rhs.backup_ = this->backup_; + this->backup_ = tmp; + } + +public: // queries + + T& get() + { + return *backup_; + } + + const T& get() const + { + return *backup_; + } + +}; + +template <typename T> +backup_holder<T>::backup_holder(const backup_holder&) + : backup_(0) +{ + // 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) +{ + lhs.swap(rhs); +} + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp b/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp new file mode 100644 index 0000000..823a79a --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp @@ -0,0 +1,30 @@ +//----------------------------------------------------------------------------- +// 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 new file mode 100644 index 0000000..9b8fb54 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/bool_trait_undef.hpp @@ -0,0 +1,21 @@ +//----------------------------------------------------------------------------- +// 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 new file mode 100644 index 0000000..f23f174 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp @@ -0,0 +1,48 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/cast_storage.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) + +#ifndef BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP +#define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP + +#include "boost/config.hpp" + +namespace boost { +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) + ) +{ + return *static_cast<T*>(storage); +} + +template <typename T> +inline const T& cast_storage( + const void* storage + BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) + ) +{ + return *static_cast<const T*>(storage); +} + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/config.hpp b/3rdParty/Boost/src/boost/variant/detail/config.hpp new file mode 100644 index 0000000..eb18201 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/config.hpp @@ -0,0 +1,38 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/config.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) + +#ifndef BOOST_VARIANT_DETAIL_CONFIG_HPP +#define BOOST_VARIANT_DETAIL_CONFIG_HPP + +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// 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 +// +#if !defined(BOOST_NO_SFINAE) \ + && !BOOST_WORKAROUND(BOOST_INTEL, <= 700) \ + && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) +# define BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND +#endif + +#endif // BOOST_VARIANT_DETAIL_CONFIG_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp b/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp new file mode 100644 index 0000000..76bd7c7 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp @@ -0,0 +1,162 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/enable_recursive.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) + +#ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP +#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP + +#include "boost/variant/detail/enable_recursive_fwd.hpp" +#include "boost/variant/variant_fwd.hpp" + +#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT) +# include "boost/mpl/apply.hpp" +# include "boost/mpl/eval_if.hpp" +# include "boost/mpl/lambda.hpp" +#endif + +#include "boost/variant/detail/substitute.hpp" +#include "boost/mpl/aux_/config/ctps.hpp" +#include "boost/mpl/bool_fwd.hpp" +#include "boost/mpl/if.hpp" +#include "boost/mpl/or.hpp" +#include "boost/type_traits/is_pointer.hpp" +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/is_same.hpp" + +#include "boost/variant/recursive_wrapper.hpp" + +namespace boost { +namespace detail { namespace variant { + +#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +# define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \ + substitute< T , Dest , Source > \ + /**/ + +#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class template rebind1 +// +// Limited workaround in case 'substitute' metafunction unavailable. +// + +template <typename T, typename U1> +struct rebind1 +{ +private: + typedef typename mpl::lambda< + mpl::identity<T> + >::type le_; + +public: + typedef typename mpl::eval_if< + is_same< le_, mpl::identity<T> > + , le_ // identity<T> + , mpl::apply1<le_, U1> + >::type type; +}; + +# define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \ + rebind1< T , Dest > \ + /**/ + +#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +/////////////////////////////////////////////////////////////////////////////// +// (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_ + ) +{ +}; + +template <typename T, typename RecursiveVariant> +struct enable_recursive< T,RecursiveVariant,mpl::false_ > +{ +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_< + is_same< t_,T > + , is_reference<t_> + , is_pointer<t_> + > + , 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). +// +template <typename RecursiveVariant, typename NoWrapper> +struct quoted_enable_recursive +{ + template <typename T> + struct apply + : enable_recursive<T, RecursiveVariant, NoWrapper> + { + }; +}; + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp b/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp new file mode 100644 index 0000000..3336c1f --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp @@ -0,0 +1,116 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/enable_recursive_fwd.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) + +#ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP +#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_ +{ +}; + +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 +// (i.e., not a reference or pointer) *and* NoWrapper is false_. +// +template < + typename T + , typename RecursiveVariant + , typename NoWrapper = mpl::false_ + > +struct enable_recursive; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction class quoted_enable_recursive +// +// Same behavior as enable_recursive metafunction (see above). +// +template < + typename RecursiveVariant + , typename NoWrapper = mpl::false_ + > +struct quoted_enable_recursive; + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp b/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp new file mode 100644 index 0000000..cc1f25b --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/forced_return.hpp @@ -0,0 +1,104 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/forced_return.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) + +#ifndef BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP +#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) ) +{ + // 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); +} + +template <> +inline void forced_return<void>( BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(void) ) +{ + // logical error: should never be here! (see above) + BOOST_ASSERT(false); +} + +#elif !defined(BOOST_MSVC) + +// workaround implementation +// +// TODO: Determine the most efficient way to handle this -- as below? by +// 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) ) +{ + // 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) + +// 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) ) +{ + // logical error: should never be here! (see above) + BOOST_ASSERT(false); + + forced_return_no_return(); +} + +#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/generic_result_type.hpp b/3rdParty/Boost/src/boost/variant/detail/generic_result_type.hpp new file mode 100644 index 0000000..b3fbb19 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/generic_result_type.hpp @@ -0,0 +1,88 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/generic_result_type.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) + +#ifndef BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP +#define BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP + +#include "boost/config.hpp" + +////////////////////////////////////////////////////////////////////////// +// (workaround) macro BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE +// +// On compilers with BOOST_NO_VOID_RETURNS, this macro provides a route +// to a single syntax for dealing with template functions that may (but +// not necessarily) return nothing (i.e. void). +// +// BOOST_VARIANT_AUX_RETURN_VOID provided for compilers w/ (erroneous?) +// warnings about non-void functions not returning a value. +// + +#if !defined(BOOST_NO_VOID_RETURNS) + +#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \ + T \ + /**/ + +#define BOOST_VARIANT_AUX_RETURN_VOID \ + /**/ + +#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE \ + void \ + /**/ + +#else // defined(BOOST_NO_VOID_RETURNS) + +namespace boost { +namespace detail { namespace variant { + +struct fake_return_void +{ + fake_return_void() + { + } + + template <typename T> + fake_return_void(const T&) + { + } +}; + +template <typename T> +struct no_void_returns_helper +{ + typedef T type; +}; + +template <> +struct no_void_returns_helper<void> +{ + typedef fake_return_void type; +}; + +}} // namespace detail::variant +} // namespace boost + +#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \ + BOOST_DEDUCED_TYPENAME \ + ::boost::detail::variant::no_void_returns_helper< T >::type \ + /**/ + +#define BOOST_VARIANT_AUX_RETURN_VOID \ + return ::boost::detail::variant::fake_return_void() \ + /**/ + +#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE \ + ::boost::detail::variant::fake_return_void + +#endif // BOOST_NO_VOID_RETURNS workaround + +#endif // BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_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 new file mode 100644 index 0000000..51ca095 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/has_nothrow_move.hpp @@ -0,0 +1,106 @@ + +// (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 new file mode 100644 index 0000000..5293366 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/has_trivial_move.hpp @@ -0,0 +1,100 @@ + +// (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/initializer.hpp b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp new file mode 100644 index 0000000..b14d6c8 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp @@ -0,0 +1,265 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/initializer.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-2003 +// Eric Friedman, Itay Maman +// +// 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_INITIALIZER_HPP +#define BOOST_VARIANT_DETAIL_INITIALIZER_HPP + +#include <new> // for placement new + +#include "boost/config.hpp" + +#include "boost/call_traits.hpp" +#include "boost/detail/reference_content.hpp" +#include "boost/variant/recursive_wrapper_fwd.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" +# include "boost/mpl/deref.hpp" +# include "boost/mpl/pair.hpp" +# include "boost/mpl/protect.hpp" +#else +# include "boost/variant/variant_fwd.hpp" +# include "boost/preprocessor/cat.hpp" +# include "boost/preprocessor/enum.hpp" +# include "boost/preprocessor/repeat.hpp" +#endif + +namespace boost { +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) support to simulate standard overload resolution rules +// +// The below initializers allows variant to follow standard overload +// resolution rules over the specified set of bounded types. +// +// On compilers where using declarations in class templates can correctly +// avoid name hiding, use an optimal solution based on the variant's typelist. +// +// Otherwise, use a preprocessor workaround based on knowledge of the fixed +// size of the variant's psuedo-variadic template parameter list. +// + +#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +// (detail) quoted metafunction make_initializer_node +// +// Exposes a pair whose first type is a node in the initializer hierarchy. +// +struct make_initializer_node +{ + template <typename BaseIndexPair, typename Iterator> + struct apply + { + private: // helpers, for metafunction result (below) + + typedef typename BaseIndexPair::first + base; + typedef typename BaseIndexPair::second + index; + + class initializer_node + : public base + { + 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; + typedef typename call_traits<public_T>::param_type + param_T; + + public: // static functions + + using base::initialize; + + static int initialize(void* dest, param_T operand) + { + typedef typename boost::detail::make_reference_content< + recursive_enabled_T + >::type internal_T; + + new(dest) internal_T(operand); + return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which + } + + }; + + friend class initializer_node; + + public: // metafunction result + + typedef mpl::pair< + initializer_node + , typename mpl::next< index >::type + > type; + + }; +}; + +// (detail) class initializer_root +// +// Every level of the initializer hierarchy must expose the name +// "initialize," so initializer_root provides a dummy function: +// +class initializer_root +{ +public: // static functions + + static void initialize(); + +}; + +#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \ + BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \ + /**/ + + #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 > +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) \ + static int initialize( \ + void* dest \ + , BOOST_PP_CAT(param_T,N) operand \ + ) \ + { \ + typedef typename boost::detail::make_reference_content< \ + BOOST_PP_CAT(recursive_enabled_T,N) \ + >::type internal_T; \ + \ + new(dest) internal_T(operand); \ + return (N); /*which*/ \ + } \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION + , _ + ) + + #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 + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_AUX_INITIALIZER_T +// +// Given both the variant's typelist and a basename for forming the list of +// bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer +// most appropriate to the current compiler. +// + +#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \ + ::boost::mpl::iter_fold< \ + mpl_seq \ + , ::boost::mpl::pair< \ + ::boost::detail::variant::initializer_root \ + , ::boost::mpl::int_<0> \ + > \ + , ::boost::mpl::protect< \ + ::boost::detail::variant::make_initializer_node \ + > \ + >::type::first \ + /**/ + +#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + #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) \ + > \ + /**/ + +#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 new file mode 100644 index 0000000..b2c74ad --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// 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 +// +// 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 +#define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP + +#include "boost/variant/variant_fwd.hpp" + +#include "boost/mpl/list.hpp" +#include "boost/preprocessor/cat.hpp" +#include "boost/preprocessor/enum.hpp" + +namespace boost { +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction make_variant_list +// +// 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). +// +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...] +# define BOOST_VARIANT_AUX_CONVERT_VOID(z, N,_) \ + typename convert_void< BOOST_PP_CAT(T,N) >::type + + // [...so that the specified types can be passed to mpl::list...] + typedef typename mpl::list< + BOOST_PP_ENUM( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_CONVERT_VOID + , _ + ) + >::type type; + + // [...and, finally, the conversion macro can be undefined:] +# undef BOOST_VARIANT_AUX_CONVERT_VOID + +}; + +}} // 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 new file mode 100644 index 0000000..572cfbb --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/move.hpp @@ -0,0 +1,166 @@ +//----------------------------------------------------------------------------- +// 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 +// +// 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. +// See <http://www.cuj.com/experts/2102/alexandr.htm> for information on MOJO. +// Re-issued here under the Boost Software License, with permission of the original +// author (Andrei Alexandrescu). + + +#ifndef BOOST_VARIANT_DETAIL_MOVE_HPP +#define BOOST_VARIANT_DETAIL_MOVE_HPP + +#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" + +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; + +}; + +////////////////////////////////////////////////////////////////////////// +// 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 + +// [...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) +{ + T tmp( boost::detail::variant::move(lhs) ); + lhs = boost::detail::variant::move(rhs); + rhs = boost::detail::variant::move(tmp); +} + +}} // namespace detail::move_swap + +template <typename T> +inline void move_swap(T& lhs, T& rhs) +{ + using detail::move_swap::swap; + + swap(lhs, rhs); +} + +#endif // workaround + +}} // namespace detail::variant +} // namespace boost + +#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 new file mode 100644 index 0000000..bdd69ad --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp @@ -0,0 +1,95 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/over_sequence.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// Portions Copyright (C) 2002 David Abrahams +// +// 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_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 { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class over_sequence +// +// Wrapper used to indicate bounded types for variant are from type sequence. +// +template <typename Types> +struct over_sequence +{ + typedef Types type; +}; + +/////////////////////////////////////////////////////////////////////////////// +// (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_ +{ +}; + +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 new file mode 100644 index 0000000..97fe205 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/substitute.hpp @@ -0,0 +1,231 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +//----------------------------------------------------------------------------- +// boost variant/detail/substitute.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) + +#ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP +#define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP + +#include "boost/mpl/aux_/config/ctps.hpp" + +#include "boost/variant/detail/substitute_fwd.hpp" +#include "boost/mpl/aux_/lambda_arity_param.hpp" +#include "boost/mpl/aux_/preprocessor/params.hpp" +#include "boost/mpl/aux_/preprocessor/repeat.hpp" +#include "boost/mpl/int_fwd.hpp" +#include "boost/mpl/limits/arity.hpp" +#include "boost/preprocessor/cat.hpp" +#include "boost/preprocessor/empty.hpp" +#include "boost/preprocessor/arithmetic/inc.hpp" +#include "boost/preprocessor/iterate.hpp" + +namespace boost { +namespace detail { namespace variant { + +#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction substitute +// +// Substitutes one type for another in the given type expression. +// + +// +// primary template +// +template < + typename T, typename Dest, typename Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( + typename Arity /* = ... (see substitute_fwd.hpp) */ + ) + > +struct substitute +{ + typedef T type; +}; + +// +// tag substitution specializations +// + +#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(CV_) \ + template <typename Dest, typename Source> \ + struct substitute< \ + CV_ Source \ + , Dest \ + , Source \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \ + > \ + { \ + typedef CV_ Dest type; \ + }; \ + /**/ + +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG( BOOST_PP_EMPTY() ) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(volatile) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const volatile) + +#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG + +// +// pointer specializations +// +#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(CV_) \ + template <typename T, typename Dest, typename Source> \ + struct substitute< \ + T * CV_ \ + , Dest \ + , Source \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \ + > \ + { \ + typedef typename substitute< \ + T, Dest, Source \ + >::type * CV_ type; \ + }; \ + /**/ + +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER( BOOST_PP_EMPTY() ) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(volatile) +BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const volatile) + +#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER + +// +// reference specializations +// +template <typename T, typename Dest, typename Source> +struct substitute< + T& + , Dest + , Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) + > +{ + typedef typename substitute< + T, Dest, Source + >::type & type; +}; + +// +// template expression (i.e., F<...>) specializations +// + +#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \ + typedef typename substitute< \ + BOOST_PP_CAT(U,N), Dest, Source \ + >::type BOOST_PP_CAT(u,N); \ + /**/ + +#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \ + BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \ + /**/ + +#define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY) +#define BOOST_PP_FILENAME_1 "boost/variant/detail/substitute.hpp" +#include BOOST_PP_ITERATE() + +#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL +#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF + +#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP + +///// iteration, depth == 1 + +#elif BOOST_PP_ITERATION_DEPTH() == 1 +#define i BOOST_PP_FRAME_ITERATION(1) + +#if i > 0 + +// +// template specializations +// +template < + template < BOOST_MPL_PP_PARAMS(i,typename P) > class T + , BOOST_MPL_PP_PARAMS(i,typename U) + , typename Dest + , typename Source + > +struct substitute< + T< BOOST_MPL_PP_PARAMS(i,U) > + , Dest + , Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>) + > +{ +private: + BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _) + +public: + typedef T< BOOST_MPL_PP_PARAMS(i,u) > type; +}; + +// +// function specializations +// +template < + typename R + , BOOST_MPL_PP_PARAMS(i,typename U) + , typename Dest + , typename Source + > +struct substitute< + R (*)( BOOST_MPL_PP_PARAMS(i,U) ) + , Dest + , Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) + > +{ +private: + typedef typename substitute< R, Dest, Source >::type r; + BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _) + +public: + typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) ); +}; + +#elif i == 0 + +// +// zero-arg function specialization +// +template < + typename R, typename Dest, typename Source + > +struct substitute< + R (*)( void ) + , Dest + , Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) + > +{ +private: + typedef typename substitute< R, Dest, Source >::type r; + +public: + typedef r (*type)( void ); +}; + +#endif // i + +#undef i +#endif // BOOST_PP_IS_ITERATING diff --git a/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp b/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp new file mode 100644 index 0000000..1723847 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp @@ -0,0 +1,59 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/substitute_fwd.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) + +#ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP +#define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP + +#include "boost/mpl/aux_/lambda_arity_param.hpp" +#include "boost/mpl/aux_/template_arity.hpp" +#include "boost/mpl/int_fwd.hpp" + + +/////////////////////////////////////////////////////////////////////////////// +// BOOST_VARIANT_DETAIL_NO_SUBSTITUTE +// +// Defined if 'substitute' is not implementable on the current compiler. +// + +#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 { + +#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +/////////////////////////////////////////////////////////////////////////////// +// metafunction substitute +// +// Substitutes one type for another in the given type expression. +// +template < + typename T, typename Dest, typename Source + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( + typename Arity = mpl::int_< mpl::aux::template_arity<T>::value > + ) + > +struct substitute; + +#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/variant_io.hpp b/3rdParty/Boost/src/boost/variant/detail/variant_io.hpp new file mode 100644 index 0000000..c72491a --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/variant_io.hpp @@ -0,0 +1,92 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/variant_io.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-2003 +// Eric Friedman, Itay Maman +// +// 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_VARIANT_IO_HPP +#define BOOST_VARIANT_DETAIL_VARIANT_IO_HPP + +#include <iosfwd> // for std::basic_ostream forward declare + +#include "boost/variant/variant_fwd.hpp" + +#include "boost/detail/templated_streams.hpp" +#include "boost/variant/static_visitor.hpp" + +namespace boost { + +/////////////////////////////////////////////////////////////////////////////// +// function template operator<< +// +// Outputs the content of the given variant to the given ostream. +// + +// forward declare (allows output of embedded variant< variant< ... >, ... >) +template < + BOOST_TEMPLATED_STREAM_ARGS(E,T) + BOOST_TEMPLATED_STREAM_COMMA + BOOST_VARIANT_ENUM_PARAMS(typename U) + > +inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<( + BOOST_TEMPLATED_STREAM(ostream, E,T)& out + , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs + ); + +namespace detail { namespace variant { + +template <typename OStream> +class printer + : public boost::static_visitor<> +{ +private: // representation + + OStream& out_; + +public: // structors + + explicit printer(OStream& out) + : out_( out ) + { + } + +public: // visitor interface + + template <typename T> + void operator()(const T& operand) const + { + out_ << operand; + } + +}; + +}} // namespace detail::variant + +template < + BOOST_TEMPLATED_STREAM_ARGS(E,T) + BOOST_TEMPLATED_STREAM_COMMA + BOOST_VARIANT_ENUM_PARAMS(typename U) + > +inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<( + BOOST_TEMPLATED_STREAM(ostream, E,T)& out + , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs + ) +{ + detail::variant::printer< + BOOST_TEMPLATED_STREAM(ostream, E,T) + > visitor(out); + + rhs.apply_visitor(visitor); + + return out; +} + +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_VARIANT_IO_HPP diff --git a/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp b/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp new file mode 100644 index 0000000..36ab906 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp @@ -0,0 +1,286 @@ +//----------------------------------------------------------------------------- +// boost variant/detail/visitation_impl.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) + +#ifndef BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP +#define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP + +#include "boost/config.hpp" + +#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" + + +/////////////////////////////////////////////////////////////////////////////// +// 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) +# define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT \ + BOOST_VARIANT_LIMIT_TYPES +#endif + +namespace boost { +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class apply_visitor_unrolled +// +// Tag type indicates when visitation_impl is unrolled. +// +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; + + typedef typename mpl::next<Iter>::type next_iter; + typedef visitation_impl_step< + next_iter, LastIter + > next; +}; + +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. +// + +template <typename Visitor, typename VoidPtrCV, typename T> +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +visitation_impl_invoke_impl( + int, Visitor& visitor, VoidPtrCV storage, T* + , mpl::true_// never_uses_backup + ) +{ + return visitor.internal_visit( + cast_storage<T>(storage), 1L + ); +} + +template <typename Visitor, typename VoidPtrCV, typename T> +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +visitation_impl_invoke_impl( + int internal_which, Visitor& visitor, VoidPtrCV storage, T* + , mpl::false_// never_uses_backup + ) +{ + if (internal_which >= 0) + { + return visitor.internal_visit( + cast_storage<T>(storage), 1L + ); + } + else + { + return visitor.internal_visit( + cast_storage< backup_holder<T> >(storage), 1L + ); + } +} + +template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag> +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +visitation_impl_invoke( + int internal_which, Visitor& visitor, VoidPtrCV storage, T* t + , NoBackupFlag + , int + ) +{ + typedef typename mpl::or_< + NoBackupFlag + , has_nothrow_move_constructor<T> + , has_nothrow_copy<T> + >::type never_uses_backup; + + return visitation_impl_invoke_impl( + internal_which, visitor, storage, t + , never_uses_backup() + ); +} + +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); + typedef typename Visitor::result_type result_type; + return ::boost::detail::variant::forced_return< result_type >(); +} + +/////////////////////////////////////////////////////////////////////////////// +// (detail) function template visitation_impl +// +// Invokes the given visitor on the type in the given variant storage. +// + +template < + typename W, typename S + , typename Visitor, typename VPCV + , typename NBF + > +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +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); + typedef typename Visitor::result_type result_type; + return ::boost::detail::variant::forced_return< result_type >(); +} + +template < + typename Which, typename step0 + , typename Visitor, typename VoidPtrCV + , typename NoBackupFlag + > +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +visitation_impl( + const int internal_which, const int logical_which + , Visitor& visitor, VoidPtrCV storage + , mpl::false_ // is_apply_visitor_unrolled + , NoBackupFlag no_backup_flag + , Which* = 0, step0* = 0 + ) +{ + // Typedef apply_visitor_unrolled steps and associated types... +# define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF(z, N, _) \ + typedef typename BOOST_PP_CAT(step,N)::type BOOST_PP_CAT(T,N); \ + typedef typename BOOST_PP_CAT(step,N)::next \ + BOOST_PP_CAT(step, BOOST_PP_INC(N)); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_VISITATION_UNROLLING_LIMIT + , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF + , _ + ) + +# undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF + + // ...switch on the target which-index value... + switch (logical_which) + { + + // ...applying the appropriate case: +# define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE(z, N, _) \ + case (Which::value + (N)): \ + return visitation_impl_invoke( \ + internal_which, visitor, storage \ + , static_cast<BOOST_PP_CAT(T,N)*>(0) \ + , no_backup_flag, 1L \ + ); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_VISITATION_UNROLLING_LIMIT + , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE + , _ + ) + +# undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE + + } + + // If not handled in this iteration, continue unrolling: + typedef mpl::int_< + Which::value + (BOOST_VARIANT_VISITATION_UNROLLING_LIMIT) + > next_which; + + typedef BOOST_PP_CAT(step, BOOST_VARIANT_VISITATION_UNROLLING_LIMIT) + next_step; + + typedef typename next_step::type next_type; + typedef typename is_same< next_type,apply_visitor_unrolled >::type + is_apply_visitor_unrolled; + + return visitation_impl( + internal_which, logical_which + , visitor, storage + , is_apply_visitor_unrolled() + , no_backup_flag + , static_cast<next_which*>(0), static_cast<next_step*>(0) + ); +} + +}} // namespace detail::variant +} // namespace boost + +#endif // BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP diff --git a/3rdParty/Boost/src/boost/variant/get.hpp b/3rdParty/Boost/src/boost/variant/get.hpp new file mode 100644 index 0000000..99a65f6 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/get.hpp @@ -0,0 +1,202 @@ +//----------------------------------------------------------------------------- +// boost variant/get.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman, Itay Maman +// +// 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_GET_HPP +#define BOOST_VARIANT_GET_HPP + +#include <exception> + +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" +#include "boost/utility/addressof.hpp" +#include "boost/variant/variant_fwd.hpp" + +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/add_pointer.hpp" + +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# include "boost/mpl/bool.hpp" +# include "boost/mpl/or.hpp" +# include "boost/type_traits/is_same.hpp" +#endif + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// class bad_get +// +// The exception thrown in the event of a failed get of a value. +// +class bad_get + : public std::exception +{ +public: // std::exception implementation + + virtual const char * what() const throw() + { + return "boost::bad_get: " + "failed value get using boost::get"; + } + +}; + +////////////////////////////////////////////////////////////////////////// +// function template get<T> +// +// Retrieves content of given variant object if content is of type T. +// Otherwise: pointer ver. returns 0; reference ver. throws bad_get. +// + +namespace detail { namespace variant { + +// (detail) class template get_visitor +// +// Generic static visitor that: if the value is of the specified type, +// returns a pointer to the value it visits; else a null pointer. +// +template <typename T> +struct get_visitor +{ +private: // private typedefs + + typedef typename add_pointer<T>::type pointer; + typedef typename add_reference<T>::type reference; + +public: // visitor typedefs + + typedef pointer result_type; + +public: // visitor interfaces + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + + pointer operator()(reference operand) const + { + return boost::addressof(operand); + } + + template <typename U> + pointer operator()(const U&) const + { + return static_cast<pointer>(0); + } + +#else // MSVC6 + +private: // helpers, for visitor interfaces (below) + + pointer execute_impl(reference operand, mpl::true_) const + { + return boost::addressof(operand); + } + + template <typename U> + pointer execute_impl(const U& operand, mpl::false_) const + { + return static_cast<pointer>(0); + } + +public: // visitor interfaces + + template <typename U> + pointer operator()(U& operand) const + { + // MSVC6 finds normal implementation (above) ambiguous, + // so we must explicitly disambiguate + + typedef typename mpl::or_< + is_same<U, T> + , is_same<const U, T> + >::type U_is_T; + + return execute_impl(operand, U_is_T()); + } + +#endif // MSVC6 workaround + +}; + +}} // namespace detail::variant + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) +# define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t) \ + BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) +#else +# define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t) \ + , t* = 0 +#endif + +template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) > +inline + typename add_pointer<U>::type +get( + boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand + BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U) + ) +{ + typedef typename add_pointer<U>::type U_ptr; + if (!operand) return static_cast<U_ptr>(0); + + detail::variant::get_visitor<U> v; + return operand->apply_visitor(v); +} + +template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) > +inline + typename add_pointer<const U>::type +get( + const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand + BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U) + ) +{ + typedef typename add_pointer<const U>::type U_ptr; + if (!operand) return static_cast<U_ptr>(0); + + detail::variant::get_visitor<const U> v; + return operand->apply_visitor(v); +} + +template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) > +inline + typename add_reference<U>::type +get( + boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand + BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U) + ) +{ + typedef typename add_pointer<U>::type U_ptr; + U_ptr result = get<U>(&operand); + + if (!result) + throw bad_get(); + return *result; +} + +template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) > +inline + typename add_reference<const U>::type +get( + const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand + BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U) + ) +{ + typedef typename add_pointer<const U>::type U_ptr; + U_ptr result = get<const U>(&operand); + + if (!result) + throw bad_get(); + return *result; +} + +} // namespace boost + +#endif // BOOST_VARIANT_GET_HPP diff --git a/3rdParty/Boost/src/boost/variant/recursive_variant.hpp b/3rdParty/Boost/src/boost/variant/recursive_variant.hpp new file mode 100644 index 0000000..c4cd3b0 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/recursive_variant.hpp @@ -0,0 +1,182 @@ +//----------------------------------------------------------------------------- +// boost variant/recursive_variant.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) + +#ifndef BOOST_VARIANT_RECURSIVE_VARIANT_HPP +#define BOOST_VARIANT_RECURSIVE_VARIANT_HPP + +#include "boost/variant/variant_fwd.hpp" +#include "boost/variant/detail/enable_recursive.hpp" +#include "boost/variant/detail/substitute_fwd.hpp" +#include "boost/variant/detail/make_variant_list.hpp" +#include "boost/variant/detail/over_sequence.hpp" + +#include "boost/mpl/aux_/lambda_arity_param.hpp" + +#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) +# include "boost/mpl/eval_if.hpp" +# include "boost/mpl/identity.hpp" +# include "boost/mpl/protect.hpp" +# include "boost/mpl/transform.hpp" +#else +# include "boost/preprocessor/cat.hpp" +# include "boost/preprocessor/repeat.hpp" +#endif + +#include "boost/mpl/bool.hpp" +#include "boost/mpl/is_sequence.hpp" +#include "boost/variant/variant.hpp" + +namespace boost { + +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction specialization substitute +// +// Handles embedded variant types when substituting for recursive_variant_. +// + +#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +template < + BOOST_VARIANT_ENUM_PARAMS(typename T) + , typename RecursiveVariant + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) + > +struct substitute< + ::boost::variant< + recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > + , RecursiveVariant + , ::boost::recursive_variant_ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity) + > +{ + typedef ::boost::variant< + recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > type; +}; + +template < + BOOST_VARIANT_ENUM_PARAMS(typename T) + , typename RecursiveVariant + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) + > +struct substitute< + ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > + , RecursiveVariant + , ::boost::recursive_variant_ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity) + > +{ + +#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for metafunction result (below) + + typedef typename mpl::eval_if< + ::boost::detail::variant::is_over_sequence<T0> + , mpl::identity< T0 > + , make_variant_list< BOOST_VARIANT_ENUM_PARAMS(T) > + >::type initial_types; + + typedef typename mpl::transform< + initial_types + , mpl::protect< quoted_enable_recursive<RecursiveVariant,mpl::true_> > + >::type types; + +public: // metafunction result + + typedef ::boost::variant< types > type; + +#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for metafunction result (below) + + #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \ + typedef typename enable_recursive< \ + BOOST_PP_CAT(T,N) \ + , RecursiveVariant \ + , mpl::true_ \ + >::type BOOST_PP_CAT(wknd_T,N); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + , _ + ) + + #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + +public: // metafunction result + + typedef ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(wknd_T) > type; + +#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround + +}; + +#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +// +// no specializations: embedded variants unsupported on these compilers! +// + +#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +}} // namespace detail::variant + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template < BOOST_VARIANT_ENUM_PARAMS(typename T) > +struct make_recursive_variant +{ +public: // metafunction result + + typedef boost::variant< + detail::variant::recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > type; + +}; + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant_over +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template <typename Types> +struct make_recursive_variant_over +{ +private: // precondition assertions + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value )); +#endif + +public: // metafunction result + + typedef typename make_recursive_variant< + detail::variant::over_sequence< Types > + >::type type; + +}; + +} // namespace boost + +#endif // BOOST_VARIANT_RECURSIVE_VARIANT_HPP diff --git a/3rdParty/Boost/src/boost/variant/recursive_wrapper.hpp b/3rdParty/Boost/src/boost/variant/recursive_wrapper.hpp new file mode 100644 index 0000000..ddc7002 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/recursive_wrapper.hpp @@ -0,0 +1,123 @@ +//----------------------------------------------------------------------------- +// boost variant/recursive_wrapper.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-2003 +// Eric Friedman, Itay Maman +// +// 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_RECURSIVE_WRAPPER_HPP +#define BOOST_VARIANT_RECURSIVE_WRAPPER_HPP + +#include "boost/variant/recursive_wrapper_fwd.hpp" +#include "boost/checked_delete.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// class template recursive_wrapper +// +// See docs and recursive_wrapper_fwd.hpp for more information. +// + +template <typename T> +class recursive_wrapper +{ +public: // typedefs + + typedef T type; + +private: // representation + + T* p_; + +public: // structors + + ~recursive_wrapper(); + recursive_wrapper(); + + recursive_wrapper(const recursive_wrapper& operand); + recursive_wrapper(const T& operand); + +private: // helpers, for modifiers (below) + + void assign(const T& rhs); + +public: // modifiers + + recursive_wrapper& operator=(const recursive_wrapper& rhs) + { + assign( rhs.get() ); + return *this; + } + + recursive_wrapper& operator=(const T& rhs) + { + assign( rhs ); + return *this; + } + + void swap(recursive_wrapper& operand) + { + T* temp = operand.p_; + operand.p_ = p_; + p_ = temp; + } + +public: // queries + + T& get() { return *get_pointer(); } + const T& get() const { return *get_pointer(); } + + T* get_pointer() { return p_; } + const T* get_pointer() const { return p_; } + +}; + +template <typename T> +recursive_wrapper<T>::~recursive_wrapper() +{ + boost::checked_delete(p_); +} + +template <typename T> +recursive_wrapper<T>::recursive_wrapper() + : p_(new T) +{ +} + +template <typename T> +recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand) + : p_(new T( operand.get() )) +{ +} + +template <typename T> +recursive_wrapper<T>::recursive_wrapper(const T& operand) + : p_(new T(operand)) +{ +} + +template <typename T> +void recursive_wrapper<T>::assign(const T& rhs) +{ + this->get() = rhs; +} + +// function template swap +// +// Swaps two recursive_wrapper<T> objects of the same type T. +// +template <typename T> +inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) +{ + lhs.swap(rhs); +} + +} // namespace boost + +#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_HPP diff --git a/3rdParty/Boost/src/boost/variant/recursive_wrapper_fwd.hpp b/3rdParty/Boost/src/boost/variant/recursive_wrapper_fwd.hpp new file mode 100644 index 0000000..69a0ec7 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/recursive_wrapper_fwd.hpp @@ -0,0 +1,147 @@ +//----------------------------------------------------------------------------- +// boost variant/recursive_wrapper_fwd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Eric Friedman, Itay Maman +// +// Portions Copyright (C) 2002 David Abrahams +// +// 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_RECURSIVE_WRAPPER_FWD_HPP +#define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_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 + +#include "boost/mpl/aux_/lambda_support.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// class template recursive_wrapper +// +// Enables recursive types in templates by breaking cyclic dependencies. +// +// For example: +// +// class my; +// +// typedef variant< int, recursive_wrapper<my> > var; +// +// class my { +// var var_; +// ... +// }; +// +template <typename T> class recursive_wrapper; + +/////////////////////////////////////////////////////////////////////////////// +// metafunction is_recursive_wrapper (modeled on code by David Abrahams) +// +// True iff specified type matches recursive_wrapper<T>. +// + +namespace detail { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct is_recursive_wrapper_impl + : mpl::false_ +{ +}; + +template <typename T> +struct is_recursive_wrapper_impl< recursive_wrapper<T> > + : mpl::true_ +{ +}; + +#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +typedef char (&yes_recursive_wrapper_t)[1]; +typedef char (&no_recursive_wrapper_t)[2]; + +no_recursive_wrapper_t is_recursive_wrapper_test(...); + +template<typename T> +yes_recursive_wrapper_t is_recursive_wrapper_test( + type< ::boost::recursive_wrapper<T> > + ); + +template<typename T> +struct is_recursive_wrapper_impl +{ + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(is_recursive_wrapper_test(type<T>())) + == sizeof(yes_recursive_wrapper_t) + )); +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_recursive_wrapper + , T + , (::boost::detail::is_recursive_wrapper_impl<T>::value) + ) + +/////////////////////////////////////////////////////////////////////////////// +// metafunction unwrap_recursive +// +// If specified type T matches recursive_wrapper<U>, then U; else T. +// + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct unwrap_recursive +{ + typedef T type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T)) +}; + +template <typename T> +struct unwrap_recursive< recursive_wrapper<T> > +{ + typedef T type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,unwrap_recursive,(T)) +}; + +#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template <typename T> +struct unwrap_recursive + : mpl::eval_if< + is_recursive_wrapper<T> + , T + , mpl::identity< T > + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T)) +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP diff --git a/3rdParty/Boost/src/boost/variant/static_visitor.hpp b/3rdParty/Boost/src/boost/variant/static_visitor.hpp new file mode 100644 index 0000000..b59b6f5 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/static_visitor.hpp @@ -0,0 +1,97 @@ +//----------------------------------------------------------------------------- +// boost variant/static_visitor.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_STATIC_VISITOR_HPP +#define BOOST_VARIANT_STATIC_VISITOR_HPP + +#include "boost/config.hpp" +#include "boost/detail/workaround.hpp" + +#include "boost/mpl/if.hpp" +#include "boost/type_traits/is_base_and_derived.hpp" + +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# include "boost/type_traits/is_same.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// class template static_visitor +// +// An empty base class that typedefs the return type of a deriving static +// visitor. The class is analogous to std::unary_function in this role. +// + +namespace detail { + + struct is_static_visitor_tag { }; + + typedef void static_visitor_default_return; + +} // namespace detail + +template <typename R = ::boost::detail::static_visitor_default_return> +class static_visitor + : public detail::is_static_visitor_tag +{ +public: // typedefs + + typedef R result_type; + +protected: // for use as base class only + + static_visitor() { } + ~static_visitor() { } + +}; + +////////////////////////////////////////////////////////////////////////// +// metafunction is_static_visitor +// +// Value metafunction indicates whether the specified type derives from +// static_visitor<...>. +// +// NOTE #1: This metafunction does NOT check whether the specified type +// fulfills the requirements of the StaticVisitor concept. +// +// NOTE #2: This template never needs to be specialized! +// + +namespace detail { + +template <typename T> +struct is_static_visitor_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::is_base_and_derived< + detail::is_static_visitor_tag, + T + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_static_visitor + , T + , (::boost::detail::is_static_visitor_impl<T>::value) + ) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_VARIANT_STATIC_VISITOR_HPP diff --git a/3rdParty/Boost/src/boost/variant/variant.hpp b/3rdParty/Boost/src/boost/variant/variant.hpp new file mode 100644 index 0000000..7e3c9e8 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/variant.hpp @@ -0,0 +1,1862 @@ +//----------------------------------------------------------------------------- +// boost variant/variant.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-2003 +// Eric Friedman, Itay Maman +// +// 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_VARIANT_HPP +#define BOOST_VARIANT_VARIANT_HPP + +#include <cstddef> // for std::size_t +#include <new> // for placement new + +#if !defined(BOOST_NO_TYPEID) +#include <typeinfo> // for typeid, std::type_info +#endif // BOOST_NO_TYPEID + +#include "boost/variant/detail/config.hpp" +#include "boost/mpl/aux_/config/eti.hpp" +#include "boost/mpl/aux_/value_wknd.hpp" + +#include "boost/variant/variant_fwd.hpp" +#include "boost/variant/detail/backup_holder.hpp" +#include "boost/variant/detail/enable_recursive_fwd.hpp" +#include "boost/variant/detail/forced_return.hpp" +#include "boost/variant/detail/initializer.hpp" +#include "boost/variant/detail/make_variant_list.hpp" +#include "boost/variant/detail/over_sequence.hpp" +#include "boost/variant/detail/visitation_impl.hpp" + +#include "boost/variant/detail/generic_result_type.hpp" +#include "boost/variant/detail/has_nothrow_move.hpp" +#include "boost/variant/detail/move.hpp" + +#include "boost/detail/reference_content.hpp" +#include "boost/aligned_storage.hpp" +#include "boost/blank.hpp" +#include "boost/static_assert.hpp" +#include "boost/preprocessor/cat.hpp" +#include "boost/preprocessor/repeat.hpp" +#include "boost/type_traits/alignment_of.hpp" +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/has_nothrow_constructor.hpp" +#include "boost/type_traits/has_nothrow_copy.hpp" +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/is_same.hpp" +#include "boost/utility/enable_if.hpp" +#include "boost/variant/recursive_wrapper_fwd.hpp" +#include "boost/variant/static_visitor.hpp" + +#include "boost/mpl/eval_if.hpp" +#include "boost/mpl/begin_end.hpp" +#include "boost/mpl/bool.hpp" +#include "boost/mpl/empty.hpp" +#include "boost/mpl/find_if.hpp" +#include "boost/mpl/front.hpp" +#include "boost/mpl/identity.hpp" +#include "boost/mpl/if.hpp" +#include "boost/mpl/int.hpp" +#include "boost/mpl/is_sequence.hpp" +#include "boost/mpl/iterator_range.hpp" +#include "boost/mpl/iter_fold_if.hpp" +#include "boost/mpl/logical.hpp" +#include "boost/mpl/max_element.hpp" +#include "boost/mpl/next.hpp" +#include "boost/mpl/deref.hpp" +#include "boost/mpl/pair.hpp" +#include "boost/mpl/protect.hpp" +#include "boost/mpl/push_front.hpp" +#include "boost/mpl/same_as.hpp" +#include "boost/mpl/size_t.hpp" +#include "boost/mpl/sizeof.hpp" +#include "boost/mpl/transform.hpp" +#include "boost/mpl/assert.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// Implementation Macros: +// +// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT +// Defined in boost/variant/detail/visitation_impl.hpp. +// +// BOOST_VARIANT_MINIMIZE_SIZE +// When #defined, implementation employs all known means to minimize the +// size of variant obje cts. However, often unsuccessful due to alignment +// issues, and potentially harmful to runtime speed, so not enabled by +// default. (TODO: Investigate further.) + +#if defined(BOOST_VARIANT_MINIMIZE_SIZE) +# include <climits> // for SCHAR_MAX +# include "boost/mpl/eval_if.hpp" +# include "boost/mpl/equal_to.hpp" +# include "boost/mpl/identity.hpp" +# include "boost/mpl/int.hpp" +# include "boost/mpl/if.hpp" +# include "boost/mpl/less.hpp" +# include "boost/mpl/long.hpp" +# include "boost/mpl/O1_size.hpp" +#endif + + +namespace boost { + +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction max_value +// +// Finds the maximum value of the unary metafunction F over Sequence. +// +template <typename Sequence, typename F> +struct max_value +{ +private: // helpers, for metafunction result (below) + + typedef typename mpl::transform1<Sequence, F>::type transformed_; + typedef typename mpl::max_element<transformed_ + + >::type max_it; + +public: // metafunction result + + typedef typename mpl::deref<max_it>::type + type; + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction find_fallback_type +// +// Provides a fallback (i.e., nothrow default-constructible) type from the +// specified sequence, or no_fallback_type if not found. +// +// This implementation is designed to prefer boost::blank over other potential +// fallback types, regardless of its position in the specified sequence. +// + +class no_fallback_type; + +struct find_fallback_type_pred +{ + template <typename Iterator> + struct apply + { + private: + typedef typename mpl::deref<Iterator>::type t_; + + public: + typedef mpl::not_< has_nothrow_constructor<t_> > type; + }; +}; + +template <typename Types> +struct find_fallback_type +{ +private: // helpers, for metafunction result (below) + + typedef typename mpl::end<Types>::type end_it; + + // [Find the first suitable fallback type...] + + typedef typename mpl::iter_fold_if< + Types + , mpl::int_<0>, mpl::protect< mpl::next<> > + , mpl::protect< find_fallback_type_pred > + >::type first_result_; + + typedef typename first_result_::first first_result_index; + typedef typename first_result_::second first_result_it; + + // [...now search the rest of the sequence for boost::blank...] + + typedef typename mpl::iter_fold_if< + mpl::iterator_range< first_result_it,end_it > + , first_result_index, mpl::protect< mpl::next<> > + , mpl::protect< mpl::not_same_as<boost::blank> > + >::type second_result_; + + typedef typename second_result_::second second_result_it; + +public: // metafunction result + + // [...and return the results of the search:] + typedef typename mpl::eval_if< + is_same< second_result_it,end_it > + , mpl::if_< + is_same< first_result_it,end_it > + , mpl::pair< no_fallback_type,no_fallback_type > + , first_result_ + > + , mpl::identity< second_result_ > + >::type type; + +}; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + +template<> +struct find_fallback_type<int> +{ + typedef mpl::pair< no_fallback_type,no_fallback_type > type; +}; + +#endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction make_storage +// +// Provides an aligned storage type capable of holding any of the types +// specified in the given type-sequence. +// + +template <typename Types, typename NeverUsesBackupFlag> +struct make_storage +{ +private: // helpers, for metafunction result (below) + + typedef typename mpl::eval_if< + NeverUsesBackupFlag + , mpl::identity< Types > + , mpl::push_front< + Types, backup_holder<void*> + > + >::type types; + + typedef typename max_value< + types, mpl::sizeof_<mpl::_1> + >::type max_size; + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) + + typedef typename max_value< + types, alignment_of<mpl::_1> + >::type max_alignment; + +#else // borland + + // temporary workaround -- use maximal alignment + typedef mpl::size_t< -1 > max_alignment; + +#endif // borland workaround + +public: // metafunction result + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + typedef ::boost::aligned_storage< + BOOST_MPL_AUX_VALUE_WKND(max_size)::value + , BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value + > type; + +#else // MSVC7 and below + + BOOST_STATIC_CONSTANT(std::size_t, msvc_max_size_c = max_size::value); + BOOST_STATIC_CONSTANT(std::size_t, msvc_max_alignment_c = max_alignment::value); + + typedef ::boost::aligned_storage< + msvc_max_size_c + , msvc_max_alignment_c + > type; + +#endif // MSVC workaround + +}; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + +template<> +struct make_storage<int,int> +{ + typedef int type; +}; + +#endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class destroyer +// +// Internal visitor that destroys the value it visits. +// +struct destroyer + : public static_visitor<> +{ +public: // visitor interfaces + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(T& operand, int) const + { + operand.~T(); + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) || \ + BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) + operand; // suppresses warnings +#endif + + BOOST_VARIANT_AUX_RETURN_VOID; + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class template known_get +// +// Visitor that returns a reference to content of the specified type. +// +// Precondition: visited variant MUST contain logical content of type T. +// +template <typename T> +class known_get + : public static_visitor<T&> +{ + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + +public: // visitor interface + + T& operator()(T& operand) const + { + return operand; + } + + template <typename U> + T& operator()(U&) const + { + // logical error to be here: see precondition above + BOOST_ASSERT(false); + return ::boost::detail::variant::forced_return< T& >(); + } + +#else // MSVC6 + +private: // helpers, for visitor interface (below) + + T& execute(T& operand, mpl::true_) const + { + return operand; + } + + template <typename U> + T& execute(U& operand, mpl::false_) const + { + // logical error to be here: see precondition above + BOOST_ASSERT(false); + return ::boost::detail::variant::forced_return< T& >(); + } + +public: // visitor interface + + template <typename U> + T& operator()(U& operand) const + { + typedef typename is_same< U,T >::type + U_is_T; + + return execute(operand, U_is_T()); + } + +#endif // MSVC6 workaround + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class copy_into +// +// Internal visitor that copies the value it visits into the given buffer. +// +class copy_into + : public static_visitor<> +{ +private: // representation + + void* storage_; + +public: // structors + + explicit copy_into(void* storage) + : storage_(storage) + { + } + +public: // internal visitor interface + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const + { + new(storage_) T( operand.get() ); + BOOST_VARIANT_AUX_RETURN_VOID; + } + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const + { + new(storage_) T( operand.get() ); + BOOST_VARIANT_AUX_RETURN_VOID; + } + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(const T& operand, int) const + { + new(storage_) T(operand); + BOOST_VARIANT_AUX_RETURN_VOID; + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class assign_storage +// +// Internal visitor that assigns the given storage (which must be a +// constructed value of the same type) to the value it visits. +// +struct assign_storage + : public static_visitor<> +{ +private: // representation + + const void* rhs_storage_; + +public: // structors + + explicit assign_storage(const void* rhs_storage) + : rhs_storage_(rhs_storage) + { + } + +public: // internal visitor interfaces + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(backup_holder<T>& lhs_content, long) const + { + lhs_content.get() + = static_cast< const backup_holder<T>* >(rhs_storage_)->get(); + BOOST_VARIANT_AUX_RETURN_VOID; + } + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(const backup_holder<T>& lhs_content, long) const + { + lhs_content.get() + = static_cast< const backup_holder<T>* >(rhs_storage_)->get(); + BOOST_VARIANT_AUX_RETURN_VOID; + } + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(T& lhs_content, int) const + { + // NOTE TO USER : + // Compile error here indicates one of variant's bounded types does + // not meet the requirements of the Assignable concept. Thus, + // variant is not Assignable. + // + // Hint: Are any of the bounded types const-qualified or references? + // + lhs_content = *static_cast< const T* >(rhs_storage_); + BOOST_VARIANT_AUX_RETURN_VOID; + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class direct_assigner +// +// Generic static visitor that: if and only if the visited value is of the +// specified type, assigns the given value to the visited value and returns +// true; else returns false. +// +template <typename T> +class direct_assigner + : public static_visitor<bool> +{ +private: // representation + + const T& rhs_; + +public: // structors + + explicit direct_assigner(const T& rhs) + : rhs_(rhs) + { + } + +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + +public: // visitor interface + + bool operator()(T& lhs) + { + lhs = rhs_; + return true; + } + + template <typename U> + bool operator()(U&) + { + return false; + } + +#else // MSVC6 + +private: // helpers, for visitor interface (below) + + bool execute(T& lhs, mpl::true_) + { + lhs = rhs_; + return true; + } + + template <typename U> + bool execute(U&, mpl::false_) + { + return false; + } + +public: // visitor interface + + template <typename U> + bool operator()(U& lhs) + { + typedef typename is_same<U,T>::type U_is_T; + return execute(lhs, U_is_T()); + } + +#endif // MSVC6 workaround + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) +private: + // silence MSVC warning C4512: assignment operator could not be generated + direct_assigner& operator= (direct_assigner const&); +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class backup_assigner +// +// Internal visitor that "assigns" the given value to the visited value, +// using backup to recover if the destroy-copy sequence fails. +// +// NOTE: This needs to be a friend of variant, as it needs access to +// indicate_which, indicate_backup_which, etc. +// +template <typename Variant, typename RhsT> +class backup_assigner + : public static_visitor<> +{ +private: // representation + + Variant& lhs_; + int rhs_which_; + const RhsT& rhs_content_; + +public: // structors + + backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content) + : lhs_(lhs) + , rhs_which_(rhs_which) + , rhs_content_(rhs_content) + { + } + +private: // helpers, for visitor interface (below) + + template <typename LhsT> + void backup_assign_impl( + LhsT& lhs_content + , mpl::true_// has_nothrow_move + ) + { + // Move lhs content to backup... + LhsT backup_lhs_content( + ::boost::detail::variant::move(lhs_content) + ); // nothrow + + // ...destroy lhs content... + lhs_content.~LhsT(); // nothrow + + try + { + // ...and attempt to copy rhs content into lhs storage: + new(lhs_.storage_.address()) RhsT(rhs_content_); + } + catch (...) + { + // In case of failure, restore backup content to lhs storage... + new(lhs_.storage_.address()) + LhsT( + ::boost::detail::variant::move(backup_lhs_content) + ); // nothrow + + // ...and rethrow: + throw; + } + + // In case of success, indicate new content type: + lhs_.indicate_which(rhs_which_); // nothrow + } + + template <typename LhsT> + void backup_assign_impl( + LhsT& lhs_content + , mpl::false_// has_nothrow_move + ) + { + // Backup lhs content... + LhsT* backup_lhs_ptr = new LhsT(lhs_content); + + // ...destroy lhs content... + lhs_content.~LhsT(); // nothrow + + try + { + // ...and attempt to copy rhs content into lhs storage: + new(lhs_.storage_.address()) RhsT(rhs_content_); + } + catch (...) + { + // In case of failure, copy backup pointer to lhs storage... + new(lhs_.storage_.address()) + backup_holder<LhsT>( backup_lhs_ptr ); // nothrow + + // ...indicate now using backup... + lhs_.indicate_backup_which( lhs_.which() ); // nothrow + + // ...and rethrow: + throw; + } + + // In case of success, indicate new content type... + lhs_.indicate_which(rhs_which_); // nothrow + + // ...and delete backup: + delete backup_lhs_ptr; // nothrow + } + +public: // visitor interface + + template <typename LhsT> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(LhsT& lhs_content, int) + { + typedef typename has_nothrow_move_constructor<LhsT>::type + nothrow_move; + + backup_assign_impl( lhs_content, nothrow_move() ); + + BOOST_VARIANT_AUX_RETURN_VOID; + } + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) +private: + // silence MSVC warning C4512: assignment operator could not be generated + backup_assigner& operator= (backup_assigner const&); +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class swap_with +// +// Visitor that swaps visited value with content of given variant. +// +// Precondition: Given variant MUST have same logical type as visited value. +// +template <typename Variant> +struct swap_with + : public static_visitor<> +{ +private: // representation + + Variant& toswap_; + +public: // structors + + explicit swap_with(Variant& toswap) + : toswap_(toswap) + { + } + +public: // internal visitor interfaces + + template <typename T> + void operator()(T& operand) const + { + // Since the precondition ensures types are same, get T... + known_get<T> getter; + T& other = toswap_.apply_visitor(getter); + + // ...and swap: + ::boost::detail::variant::move_swap( operand, other ); + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class reflect +// +// Generic static visitor that performs a typeid on the value it visits. +// + +#if !defined(BOOST_NO_TYPEID) + +class reflect + : public static_visitor<const std::type_info&> +{ +public: // visitor interfaces + + template <typename T> + const std::type_info& operator()(const T&) const + { + return typeid(T); + } + +}; + +#endif // BOOST_NO_TYPEID + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class comparer +// +// Generic static visitor that compares the content of the given lhs variant +// with the visited rhs content using Comp. +// +// Precondition: lhs.which() == rhs.which() +// +template <typename Variant, typename Comp> +class comparer + : public static_visitor<bool> +{ +private: // representation + + const Variant& lhs_; + +public: // structors + + explicit comparer(const Variant& lhs) + : lhs_(lhs) + { + } + +public: // visitor interfaces + + template <typename T> + bool operator()(const T& rhs_content) const + { + // Since the precondition ensures lhs and rhs types are same, get T... + known_get<const T> getter; + const T& lhs_content = lhs_.apply_visitor(getter); + + // ...and compare lhs and rhs contents: + return Comp()(lhs_content, rhs_content); + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class equal_comp +// +// Generic function object compares lhs with rhs using operator==. +// +struct equal_comp +{ + template <typename T> + bool operator()(const T& lhs, const T& rhs) const + { + return lhs == rhs; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class less_comp +// +// Generic function object compares lhs with rhs using operator<. +// +struct less_comp +{ + template <typename T> + bool operator()(const T& lhs, const T& rhs) const + { + return lhs < rhs; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class template invoke_visitor +// +// Internal visitor that invokes the given visitor using: +// * for wrappers (e.g., recursive_wrapper), the wrapper's held value. +// * for all other values, the value itself. +// +template <typename Visitor> +class invoke_visitor +{ +private: // representation + + Visitor& visitor_; + +public: // visitor typedefs + + typedef typename Visitor::result_type + result_type; + +public: // structors + + explicit invoke_visitor(Visitor& visitor) + : visitor_(visitor) + { + } + +#if !defined(BOOST_NO_VOID_RETURNS) + +public: // internal visitor interfaces + + template <typename T> + result_type internal_visit(T& operand, int) + { + return visitor_(operand); + } + +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) + template <typename T> + result_type internal_visit(const T& operand, int) + { + return visitor_(operand); + } +# endif + +#else // defined(BOOST_NO_VOID_RETURNS) + +private: // helpers, for internal visitor interfaces (below) + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + visit_impl(T& operand, mpl::false_) + { + return visitor_(operand); + } + + template <typename T> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + visit_impl(T& operand, mpl::true_) + { + visitor_(operand); + BOOST_VARIANT_AUX_RETURN_VOID; + } + +public: // internal visitor interfaces + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(T& operand, int) + { + typedef typename is_same<result_type, void>::type + has_void_result_type; + + return visit_impl(operand, has_void_result_type()); + } + +#endif // BOOST_NO_VOID_RETURNS) workaround + +public: // internal visitor interfaces, cont. + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(boost::recursive_wrapper<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(const boost::recursive_wrapper<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(boost::detail::reference_content<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(const boost::detail::reference_content<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(boost::detail::variant::backup_holder<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) + { + return internal_visit( operand.get(), 1L ); + } + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) +private: + // silence MSVC warning C4512: assignment operator could not be generated + invoke_visitor& operator= (invoke_visitor const&); +#endif +}; + +}} // namespace detail::variant + +/////////////////////////////////////////////////////////////////////////////// +// class template variant (concept inspired by Andrei Alexandrescu) +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template < + typename T0_ + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T) + > +class variant +{ +private: // helpers, for typedefs (below) + + typedef variant wknd_self_t; + + struct is_recursive_ + : detail::variant::is_recursive_flag<T0_> + { + }; + + typedef typename mpl::eval_if< + is_recursive_ + , T0_ + , mpl::identity< T0_ > + >::type unwrapped_T0_; + + struct is_sequence_based_ + : detail::variant::is_over_sequence<unwrapped_T0_> + { + }; + +#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for typedefs (below) + + typedef typename mpl::eval_if< + is_sequence_based_ + , unwrapped_T0_ // over_sequence<...>::type + , detail::variant::make_variant_list< + unwrapped_T0_ + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > + >::type specified_types; + + BOOST_STATIC_ASSERT(( + ::boost::mpl::not_< mpl::empty<specified_types> >::value + )); + + typedef typename mpl::eval_if< + is_recursive_ + , mpl::transform< + specified_types + , mpl::protect< + detail::variant::quoted_enable_recursive<wknd_self_t> + > + > + , mpl::identity< specified_types > + >::type recursive_enabled_types; + +public: // public typedefs + + typedef typename mpl::transform< + recursive_enabled_types + , unwrap_recursive<mpl::_1> + >::type types; + +private: // internal typedefs + + typedef typename mpl::transform< + recursive_enabled_types + , mpl::protect< detail::make_reference_content<> > + >::type internal_types; + + typedef typename mpl::front< + internal_types + >::type internal_T0; + +#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for typedefs (below) + + typedef unwrapped_T0_ T0; + + #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \ + typedef typename mpl::eval_if< \ + is_recursive_ \ + , detail::variant::enable_recursive< \ + BOOST_PP_CAT(T,N) \ + , wknd_self_t \ + > \ + , mpl::identity< BOOST_PP_CAT(T,N) > \ + >::type BOOST_PP_CAT(recursive_enabled_T,N); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + , _ + ) + + #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + + #define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \ + typedef typename unwrap_recursive< \ + BOOST_PP_CAT(recursive_enabled_T,N) \ + >::type BOOST_PP_CAT(public_T,N); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS + , _ + ) + + #undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS + +public: // public typedefs + + typedef typename detail::variant::make_variant_list< + BOOST_VARIANT_ENUM_PARAMS(public_T) + >::type types; + +private: // helpers, for internal typedefs (below) + + #define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \ + typedef detail::make_reference_content< \ + BOOST_PP_CAT(recursive_enabled_T,N) \ + >::type BOOST_PP_CAT(internal_T,N); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS + , _ + ) + + #undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS + +private: // internal typedefs + + typedef typename detail::variant::make_variant_list< + BOOST_VARIANT_ENUM_PARAMS(internal_T) + >::type internal_types; + +private: // static precondition assertions + + // NOTE TO USER : + // variant< type-sequence > syntax is not supported on this compiler! + // + BOOST_MPL_ASSERT_NOT(( is_sequence_based_ )); + +#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround + +private: // helpers, for representation (below) + + typedef typename detail::variant::find_fallback_type< + internal_types + >::type fallback_type_result_; + + typedef typename fallback_type_result_::first + fallback_type_index_; + typedef typename fallback_type_result_::second + fallback_type_; + + struct has_fallback_type_ + : mpl::not_< + is_same< fallback_type_, detail::variant::no_fallback_type > + > + { + }; + + typedef has_fallback_type_ + never_uses_backup_flag; + + typedef typename detail::variant::make_storage< + internal_types, never_uses_backup_flag + >::type storage_t; + +private: // helpers, for representation (below) + + // which_ on: + // * [0, size<internal_types>) indicates stack content + // * [-size<internal_types>, 0) indicates pointer to heap backup + // if which_ >= 0: + // * then which() -> which_ + // * else which() -> -(which_ + 1) + +#if !defined(BOOST_VARIANT_MINIMIZE_SIZE) + + typedef int which_t; + +#else // defined(BOOST_VARIANT_MINIMIZE_SIZE) + + // [if O1_size available, then attempt which_t size optimization...] + // [select signed char if fewer than SCHAR_MAX types, else signed int:] + typedef typename mpl::eval_if< + mpl::equal_to< mpl::O1_size<internal_types>, mpl::long_<-1> > + , mpl::identity< int > + , mpl::if_< + mpl::less< mpl::O1_size<internal_types>, mpl::int_<SCHAR_MAX> > + , signed char + , int + > + >::type which_t; + +#endif // BOOST_VARIANT_MINIMIZE_SIZE switch + +// representation -- private when possible +#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + private: +#else + public: +#endif + + which_t which_; + storage_t storage_; + + void indicate_which(int which) + { + which_ = static_cast<which_t>( which ); + } + + void indicate_backup_which(int which) + { + which_ = static_cast<which_t>( -(which + 1) ); + } + +private: // helpers, for queries (below) + + bool using_backup() const + { + return which_ < 0; + } + +public: // queries + + int which() const + { + // If using heap backup... + if (using_backup()) + // ...then return adjusted which_: + return -(which_ + 1); + + // Otherwise, return which_ directly: + return which_; + } + +private: // helpers, for structors (below) + + struct initializer + : BOOST_VARIANT_AUX_INITIALIZER_T( + recursive_enabled_types, recursive_enabled_T + ) + { + }; + + void destroy_content() + { + detail::variant::destroyer visitor; + this->internal_apply_visitor(visitor); + } + +public: // structors + + ~variant() + { + destroy_content(); + } + + variant() + { + // NOTE TO USER : + // Compile error from here indicates that the first bound + // type is not default-constructible, and so variant cannot + // support its own default-construction. + // + new( storage_.address() ) internal_T0(); + indicate_which(0); // zero is the index of the first bounded type + } + +private: // helpers, for structors, cont. (below) + + class convert_copy_into + : public static_visitor<int> + { + private: // representation + + void* storage_; + + public: // structors + + explicit convert_copy_into(void* storage) + : storage_(storage) + { + } + + public: // internal visitor interfaces (below) + + template <typename T> + int internal_visit(T& operand, int) const + { + // NOTE TO USER : + // Compile error here indicates one of the source variant's types + // cannot be unambiguously converted to the destination variant's + // types (or that no conversion exists). + // + return initializer::initialize(storage_, operand); + } + +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) + template <typename T> + result_type internal_visit(const T& operand, int) const + { + return initializer::initialize(storage_, operand); + } +# endif + + template <typename T> + int internal_visit(boost::detail::reference_content<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + int internal_visit(const boost::detail::reference_content<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + int internal_visit(boost::recursive_wrapper<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + template <typename T> + int internal_visit(const boost::recursive_wrapper<T>& operand, long) const + { + return internal_visit( operand.get(), 1L ); + } + + }; + + friend class convert_copy_into; + +private: // helpers, for structors, below + + template <typename T> + void convert_construct( + T& operand + , int + , mpl::false_ = mpl::false_() // is_foreign_variant + ) + { + // NOTE TO USER : + // Compile error here indicates that the given type is not + // unambiguously convertible to one of the variant's types + // (or that no conversion exists). + // + indicate_which( + initializer::initialize( + storage_.address() + , operand + ) + ); + } + + template <typename Variant> + void convert_construct( + Variant& operand + , long + , mpl::true_// is_foreign_variant + ) + { + convert_copy_into visitor(storage_.address()); + indicate_which( + operand.internal_apply_visitor(visitor) + ); + } + + template <typename Variant> + void convert_construct_variant(Variant& operand) + { + // [Determine if the given variant is itself a bounded type, or if its + // content needs to be converted (i.e., it is a 'foreign' variant):] + // + + typedef typename mpl::find_if< + types + , is_same< + add_const<mpl::_1> + , const Variant + > + >::type found_it; + + typedef typename mpl::end<types>::type not_found; + typedef typename is_same< + found_it, not_found + >::type is_foreign_variant; + + // Convert construct from operand: + convert_construct( + operand, 1L + , is_foreign_variant() + ); + } + + template <BOOST_VARIANT_ENUM_PARAMS(typename U)> + void convert_construct( + boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand + , long + ) + { + convert_construct_variant(operand); + } + + template <BOOST_VARIANT_ENUM_PARAMS(typename U)> + void convert_construct( + const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand + , long + ) + { + convert_construct_variant(operand); + } + +public: // structors, cont. + +#if !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) + + template <typename T> + variant(const T& operand) + { + convert_construct(operand, 1L); + } + + template <typename T> + variant(T& operand) + { + convert_construct(operand, 1L); + } + +#elif defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) + + // For compilers that cannot distinguish between T& and const T& in + // template constructors, but do fully support SFINAE, we can workaround: + + template <typename T> + variant(const T& operand) + { + convert_construct(operand, 1L); + } + + template <typename T> + variant( + T& operand + , typename enable_if< + mpl::not_< is_const<T> > + , void + >::type* = 0 + ) + { + convert_construct(operand, 1L); + } + +#else // !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) + + // For compilers that cannot distinguish between T& and const T& in + // template constructors, and do NOT support SFINAE, we can't workaround: + + template <typename T> + variant(const T& operand) + { + convert_construct(operand, 1L); + } + +#endif // BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING workarounds + +public: // structors, cont. + + // [MSVC6 requires copy constructor appear after template constructors] + variant(const variant& operand) + { + // Copy the value of operand into *this... + detail::variant::copy_into visitor( storage_.address() ); + operand.internal_apply_visitor(visitor); + + // ...and activate the *this's primary storage on success: + indicate_which(operand.which()); + } + +private: // helpers, for modifiers (below) + +# if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + template <typename Variant, typename RhsT> + friend class detail::variant::backup_assigner; +# endif + + // class assigner + // + // Internal visitor that "assigns" the visited value to the given variant + // by appropriate destruction and copy-construction. + // + + class assigner + : public static_visitor<> + { + private: // representation + + variant& lhs_; + int rhs_which_; + + public: // structors + + assigner(variant& lhs, int rhs_which) + : lhs_(lhs) + , rhs_which_(rhs_which) + { + } + + private: // helpers, for internal visitor interface (below) + + template <typename RhsT, typename B1, typename B2> + void assign_impl( + const RhsT& rhs_content + , mpl::true_// has_nothrow_copy + , B1// has_nothrow_move_constructor + , B2// has_fallback_type + ) + { + // Destroy lhs's content... + lhs_.destroy_content(); // nothrow + + // ...copy rhs content into lhs's storage... + new(lhs_.storage_.address()) + RhsT( rhs_content ); // nothrow + + // ...and indicate new content type: + lhs_.indicate_which(rhs_which_); // nothrow + } + + template <typename RhsT, typename B> + void assign_impl( + const RhsT& rhs_content + , mpl::false_// has_nothrow_copy + , mpl::true_// has_nothrow_move_constructor + , B// has_fallback_type + ) + { + // Attempt to make a temporary copy (so as to move it below)... + RhsT temp(rhs_content); + + // ...and upon success destroy lhs's content... + lhs_.destroy_content(); // nothrow + + // ...move the temporary copy into lhs's storage... + new(lhs_.storage_.address()) + RhsT( detail::variant::move(temp) ); // nothrow + + // ...and indicate new content type: + lhs_.indicate_which(rhs_which_); // nothrow + } + + template <typename RhsT> + void assign_impl( + const RhsT& rhs_content + , mpl::false_// has_nothrow_copy + , mpl::false_// has_nothrow_move_constructor + , mpl::true_// has_fallback_type + ) + { + // Destroy lhs's content... + lhs_.destroy_content(); // nothrow + + try + { + // ...and attempt to copy rhs's content into lhs's storage: + new(lhs_.storage_.address()) + RhsT( rhs_content ); + } + catch (...) + { + // In case of failure, default-construct fallback type in lhs's storage... + new (lhs_.storage_.address()) + fallback_type_; // nothrow + + // ...indicate construction of fallback type... + lhs_.indicate_which( + BOOST_MPL_AUX_VALUE_WKND(fallback_type_index_)::value + ); // nothrow + + // ...and rethrow: + throw; + } + + // In the event of success, indicate new content type: + lhs_.indicate_which(rhs_which_); // nothrow + } + + template <typename RhsT> + void assign_impl( + const RhsT& rhs_content + , mpl::false_// has_nothrow_copy + , mpl::false_// has_nothrow_move_constructor + , mpl::false_// has_fallback_type + ) + { + detail::variant::backup_assigner<wknd_self_t, RhsT> + visitor(lhs_, rhs_which_, rhs_content); + lhs_.internal_apply_visitor(visitor); + } + + public: // internal visitor interfaces + + template <typename RhsT> + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + internal_visit(const RhsT& rhs_content, int) + { + typedef typename has_nothrow_copy<RhsT>::type + nothrow_copy; + typedef typename mpl::or_< // reduces compile-time + nothrow_copy + , detail::variant::has_nothrow_move_constructor<RhsT> + >::type nothrow_move_constructor; + + assign_impl( + rhs_content + , nothrow_copy() + , nothrow_move_constructor() + , has_fallback_type_() + ); + + BOOST_VARIANT_AUX_RETURN_VOID; + } + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) + private: + // silence MSVC warning C4512: assignment operator could not be generated + assigner& operator= (assigner const&); +#endif + }; + + friend class assigner; + + void variant_assign(const variant& rhs) + { + // If the contained types are EXACTLY the same... + if (which_ == rhs.which_) + { + // ...then assign rhs's storage to lhs's content: + detail::variant::assign_storage visitor(rhs.storage_.address()); + this->internal_apply_visitor(visitor); + } + else + { + // Otherwise, perform general (copy-based) variant assignment: + assigner visitor(*this, rhs.which()); + rhs.internal_apply_visitor(visitor); + } + } + +private: // helpers, for modifiers (below) + + template <typename T> + void assign(const T& rhs) + { + // If direct T-to-T assignment is not possible... + detail::variant::direct_assigner<T> direct_assign(rhs); + if (this->apply_visitor(direct_assign) == false) + { + // ...then convert rhs to variant and assign: + // + // While potentially inefficient, the following construction of a + // variant allows T as any type convertible to one of the bounded + // types without excessive code redundancy. + // + variant temp(rhs); + variant_assign( detail::variant::move(temp) ); + } + } + +public: // modifiers + + template <typename T> + variant& operator=(const T& rhs) + { + assign(rhs); + return *this; + } + + // [MSVC6 requires copy assign appear after templated operator=] + variant& operator=(const variant& rhs) + { + variant_assign(rhs); + return *this; + } + + void swap(variant& rhs) + { + // If the contained types are the same... + if (which() == rhs.which()) + { + // ...then swap the values directly: + detail::variant::swap_with<variant> visitor(rhs); + this->apply_visitor(visitor); + } + else + { + // ...otherwise, perform general variant swap: + variant tmp( detail::variant::move(rhs) ); + rhs = detail::variant::move(*this); + *this = detail::variant::move(tmp); + } + } + +public: // queries + + // + // NOTE: member which() defined above. + // + + bool empty() const + { + return false; + } + +#if !defined(BOOST_NO_TYPEID) + const std::type_info& type() const + { + detail::variant::reflect visitor; + return this->apply_visitor(visitor); + } +#endif + +public: // prevent comparison with foreign types + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +# define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \ + void + +#else // MSVC7 + + // + // MSVC7 gives error about return types for above being different than + // the true comparison operator overloads: + // + +# define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \ + bool + +#endif // MSVC7 workaround + + template <typename U> + BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE + operator==(const U&) const + { + BOOST_STATIC_ASSERT( false && sizeof(U) ); + } + + template <typename U> + BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE + operator<(const U&) const + { + BOOST_STATIC_ASSERT( false && sizeof(U) ); + } + +public: // comparison operators + + // [MSVC6 requires these operators appear after template operators] + + bool operator==(const variant& rhs) const + { + if (this->which() != rhs.which()) + return false; + + detail::variant::comparer< + variant, detail::variant::equal_comp + > visitor(*this); + return rhs.apply_visitor(visitor); + } + + bool operator<(const variant& rhs) const + { + // + // Dirk Schreib suggested this collating order. + // + + if (this->which() != rhs.which()) + return this->which() < rhs.which(); + + detail::variant::comparer< + variant, detail::variant::less_comp + > visitor(*this); + return rhs.apply_visitor(visitor); + } + +// helpers, for visitation support (below) -- private when possible +#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + + template < BOOST_VARIANT_ENUM_PARAMS(typename U) > + friend class variant; + +private: + +#else// defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + +public: + +#endif// !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + + template <typename Visitor, typename VoidPtrCV> + static + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + internal_apply_visitor_impl( + int internal_which + , int logical_which + , Visitor& visitor + , VoidPtrCV storage + ) + { + typedef mpl::int_<0> first_which; + typedef typename mpl::begin<internal_types>::type first_it; + typedef typename mpl::end<internal_types>::type last_it; + + typedef detail::variant::visitation_impl_step< + first_it, last_it + > first_step; + + return detail::variant::visitation_impl( + internal_which, logical_which + , visitor, storage, mpl::false_() + , never_uses_backup_flag() + , static_cast<first_which*>(0), static_cast<first_step*>(0) + ); + } + + template <typename Visitor> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + internal_apply_visitor(Visitor& visitor) + { + return internal_apply_visitor_impl( + which_, which(), visitor, storage_.address() + ); + } + + template <typename Visitor> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + internal_apply_visitor(Visitor& visitor) const + { + return internal_apply_visitor_impl( + which_, which(), visitor, storage_.address() + ); + } + +public: // visitation support + + template <typename Visitor> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + apply_visitor(Visitor& visitor) + { + detail::variant::invoke_visitor<Visitor> invoker(visitor); + return this->internal_apply_visitor(invoker); + } + + template <typename Visitor> + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + apply_visitor(Visitor& visitor) const + { + detail::variant::invoke_visitor<Visitor> invoker(visitor); + return this->internal_apply_visitor(invoker); + } + +}; // class variant + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_variant_over +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template <typename Types> +struct make_variant_over +{ +private: // precondition assertions + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value )); +#endif + +public: // metafunction result + + typedef variant< + detail::variant::over_sequence< Types > + > type; + +}; + +/////////////////////////////////////////////////////////////////////////////// +// function template swap +// +// Swaps two variants of the same type (i.e., identical specification). +// +template < BOOST_VARIANT_ENUM_PARAMS(typename T) > +inline void swap( + variant< BOOST_VARIANT_ENUM_PARAMS(T) >& lhs + , variant< BOOST_VARIANT_ENUM_PARAMS(T) >& rhs + ) +{ + lhs.swap(rhs); +} + +} // namespace boost + +// implementation additions + +#if !defined(BOOST_NO_IOSTREAM) +#include "boost/variant/detail/variant_io.hpp" +#endif // BOOST_NO_IOSTREAM + +#endif // BOOST_VARIANT_VARIANT_HPP diff --git a/3rdParty/Boost/src/boost/variant/variant_fwd.hpp b/3rdParty/Boost/src/boost/variant/variant_fwd.hpp new file mode 100644 index 0000000..7482ad4 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/variant_fwd.hpp @@ -0,0 +1,253 @@ +//----------------------------------------------------------------------------- +// boost variant/variant_fwd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman, Itay Maman +// +// 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_VARIANT_FWD_HPP +#define BOOST_VARIANT_VARIANT_FWD_HPP + +#include "boost/variant/detail/config.hpp" + +#include "boost/blank_fwd.hpp" +#include "boost/mpl/arg.hpp" +#include "boost/mpl/limits/arity.hpp" +#include "boost/mpl/aux_/na.hpp" +#include "boost/preprocessor/cat.hpp" +#include "boost/preprocessor/enum.hpp" +#include "boost/preprocessor/enum_params.hpp" +#include "boost/preprocessor/enum_shifted_params.hpp" +#include "boost/preprocessor/repeat.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_LIMIT_TYPES +// +// Implementation-defined preprocessor symbol describing the actual +// length of variant's pseudo-variadic template parameter list. +// +#include "boost/mpl/limits/list.hpp" +#define BOOST_VARIANT_LIMIT_TYPES \ + BOOST_MPL_LIMIT_LIST_SIZE + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_NO_REFERENCE_SUPPORT +// +// Defined if variant does not support references as bounded types. +// +#if defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) \ + && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) \ + && !defined(BOOST_VARIANT_NO_REFERENCE_SUPPORT) +# define BOOST_VARIANT_NO_REFERENCE_SUPPORT +#endif + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT +// +// Defined if variant does not support make_variant_over (see below). +// +#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) +# define BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT +#endif + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT +// +// Defined if make_recursive_variant cannot be supported as documented. +// +// Note: Currently, MPL lambda facility is used as workaround if defined, and +// so only types declared w/ MPL lambda workarounds will work. +// + +#include "boost/variant/detail/substitute_fwd.hpp" + +#if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \ + && !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT) +# define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT +#endif + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY +// +// Exposes maximum allowed arity of class templates with recursive_variant +// arguments. That is, +// make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >. +// +#include "boost/mpl/limits/arity.hpp" +#define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_ENUM_PARAMS +// +// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES params. +// +// Rationale: Cleaner, simpler code for clients of variant library. +// +#define BOOST_VARIANT_ENUM_PARAMS( param ) \ + BOOST_PP_ENUM_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param) + +/////////////////////////////////////////////////////////////////////////////// +// macro BOOST_VARIANT_ENUM_SHIFTED_PARAMS +// +// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES-1 params. +// +#define BOOST_VARIANT_ENUM_SHIFTED_PARAMS( param ) \ + BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param) + + +namespace boost { + +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class void_ and class template convert_void +// +// Provides the mechanism by which void(NN) types are converted to +// mpl::void_ (and thus can be passed to mpl::list). +// +// Rationale: This is particularly needed for the using-declarations +// workaround (below), but also to avoid associating mpl namespace with +// variant in argument dependent lookups (which used to happen because of +// defaulting of template parameters to mpl::void_). +// + +struct void_; + +template <typename T> +struct convert_void +{ + typedef T type; +}; + +template <> +struct convert_void< void_ > +{ + typedef mpl::na type; +}; + +/////////////////////////////////////////////////////////////////////////////// +// (workaround) BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE +// +// Needed to work around compilers that don't support using-declaration +// overloads. (See the variant::initializer workarounds below.) +// + +#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +// (detail) tags voidNN -- NN defined on [0, BOOST_VARIANT_LIMIT_TYPES) +// +// Defines void types that are each unique and specializations of +// convert_void that yields mpl::na for each voidNN type. +// + +#define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z,N,_) \ + struct BOOST_PP_CAT(void,N); \ + \ + template <> \ + struct convert_void< BOOST_PP_CAT(void,N) > \ + { \ + typedef mpl::na type; \ + }; \ + /**/ + +BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_DETAIL_DEFINE_VOID_N + , _ + ) + +#undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N + +#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround + +}} // namespace detail::variant + +/////////////////////////////////////////////////////////////////////////////// +// (detail) macro BOOST_VARIANT_AUX_DECLARE_PARAM +// +// Template parameter list for variant and recursive_variant declarations. +// + +#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +# define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \ + typename BOOST_PP_CAT(T,N) = detail::variant::void_ \ + /**/ + +#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) + +# define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \ + typename BOOST_PP_CAT(T,N) = BOOST_PP_CAT(detail::variant::void,N) \ + /**/ + +#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround + +#define BOOST_VARIANT_AUX_DECLARE_PARAMS \ + BOOST_PP_ENUM( \ + BOOST_VARIANT_LIMIT_TYPES \ + , BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL \ + , T \ + ) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +// class template variant (concept inspired by Andrei Alexandrescu) +// +// Efficient, type-safe bounded discriminated union. +// +// Preconditions: +// - Each type must be unique. +// - No type may be const-qualified. +// +// Proper declaration form: +// variant<types> (where types is a type-sequence) +// or +// variant<T0,T1,...,Tn> (where T0 is NOT a type-sequence) +// +template < BOOST_VARIANT_AUX_DECLARE_PARAMS > class variant; + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant +// +// Exposes a boost::variant with recursive_variant_ tags (below) substituted +// with the variant itself (wrapped as needed with boost::recursive_wrapper). +// +template < BOOST_VARIANT_AUX_DECLARE_PARAMS > struct make_recursive_variant; + +#undef BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL +#undef BOOST_VARIANT_AUX_DECLARE_PARAMS + +/////////////////////////////////////////////////////////////////////////////// +// type recursive_variant_ +// +// Tag type indicates where recursive variant substitution should occur. +// +#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT) + struct recursive_variant_; +#else + typedef mpl::arg<1> recursive_variant_; +#endif + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_variant_over +// +// Result is a variant w/ types of the specified type sequence. +// +template <typename Types> struct make_variant_over; + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant_over +// +// Result is a recursive variant w/ types of the specified type sequence. +// +template <typename Types> struct make_recursive_variant_over; + +} // namespace boost + +#endif // BOOST_VARIANT_VARIANT_FWD_HPP diff --git a/3rdParty/Boost/src/boost/variant/visitor_ptr.hpp b/3rdParty/Boost/src/boost/variant/visitor_ptr.hpp new file mode 100644 index 0000000..b49a972 --- /dev/null +++ b/3rdParty/Boost/src/boost/variant/visitor_ptr.hpp @@ -0,0 +1,116 @@ +//----------------------------------------------------------------------------- +// boost variant/visitor_ptr.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-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) + +#ifndef BOOST_VARIANT_VISITOR_PTR_HPP +#define BOOST_VARIANT_VISITOR_PTR_HPP + +#include "boost/variant/bad_visit.hpp" +#include "boost/variant/static_visitor.hpp" + +#include "boost/mpl/eval_if.hpp" +#include "boost/mpl/identity.hpp" +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/is_void.hpp" + +namespace boost { + +////////////////////////////////////////////////////////////////////////// +// function template visitor_ptr +// +// Adapts a function pointer for use as visitor capable of handling +// values of a single type. Throws bad_visit if inappropriately applied. +// +template <typename T, typename R> +class visitor_ptr_t + : public static_visitor<R> +{ +private: // representation + + typedef R (*visitor_t)(T); + + visitor_t visitor_; + +public: // typedefs + + typedef R result_type; + +private: // private typedefs + + typedef typename mpl::eval_if< + is_reference<T> + , mpl::identity<T> + , add_reference<const T> + >::type argument_fwd_type; + +public: // structors + + explicit visitor_ptr_t(visitor_t visitor) + : visitor_(visitor) + { + } + +public: // static visitor interfaces + + template <typename U> + result_type operator()(const U&) const + { + throw bad_visit(); + } + +#if !defined(BOOST_NO_VOID_RETURNS) + +public: // static visitor interfaces, cont. + + result_type operator()(argument_fwd_type operand) const + { + return visitor_(operand); + } + +#else // defined(BOOST_NO_VOID_RETURNS) + +private: // helpers, for static visitor interfaces (below) + + result_type execute_impl(argument_fwd_type operand, mpl::false_) const + { + return visitor_(operand); + } + + BOOST_VARIANT_AUX_RETURN_VOID_TYPE + execute_impl(argument_fwd_type operand, mpl::true_) const + { + visitor_(operand); + BOOST_VARIANT_AUX_RETURN_VOID; + } + +public: // static visitor interfaces, cont. + + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) + operator()(argument_fwd_type operand) const + { + typedef typename is_void<result_type>::type has_void_result; + return execute_impl(operand, has_void_result()); + } + +#endif // BOOST_NO_VOID_RETURNS workaround + +}; + +template <typename R, typename T> +inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T)) +{ + return visitor_ptr_t<T,R>(visitor); +} + +} // namespace boost + +#endif// BOOST_VISITOR_VISITOR_PTR_HPP |