summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/variant')
-rw-r--r--3rdParty/Boost/src/boost/variant/apply_visitor.hpp20
-rw-r--r--3rdParty/Boost/src/boost/variant/bad_visit.hpp41
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/apply_visitor_binary.hpp172
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/apply_visitor_delayed.hpp85
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/apply_visitor_unary.hpp79
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/backup_holder.hpp94
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/bool_trait_def.hpp30
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/bool_trait_undef.hpp21
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/cast_storage.hpp48
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/config.hpp38
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/enable_recursive.hpp162
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/enable_recursive_fwd.hpp116
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/forced_return.hpp104
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/generic_result_type.hpp88
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/has_nothrow_move.hpp106
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/has_trivial_move.hpp100
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/initializer.hpp265
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/make_variant_list.hpp60
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/move.hpp166
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/over_sequence.hpp95
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/substitute.hpp231
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/substitute_fwd.hpp59
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/variant_io.hpp92
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/visitation_impl.hpp286
-rw-r--r--3rdParty/Boost/src/boost/variant/get.hpp202
-rw-r--r--3rdParty/Boost/src/boost/variant/recursive_variant.hpp182
-rw-r--r--3rdParty/Boost/src/boost/variant/recursive_wrapper.hpp123
-rw-r--r--3rdParty/Boost/src/boost/variant/recursive_wrapper_fwd.hpp147
-rw-r--r--3rdParty/Boost/src/boost/variant/static_visitor.hpp97
-rw-r--r--3rdParty/Boost/src/boost/variant/variant.hpp1862
-rw-r--r--3rdParty/Boost/src/boost/variant/variant_fwd.hpp253
-rw-r--r--3rdParty/Boost/src/boost/variant/visitor_ptr.hpp116
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