summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2010-08-08 18:41:53 (GMT)
committerRemko Tronçon <git@el-tramo.be>2010-08-08 18:41:53 (GMT)
commit19df82042f44c201e5a2821b4fa35465e33a1c90 (patch)
tree1746bddfa31ce2a6488ef5186036a049a255c9da /3rdParty/Boost/src/boost/variant/variant.hpp
parent4a5a0977f661bf5c7c34ee7aa48b35073a682203 (diff)
downloadswift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.zip
swift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.tar.bz2
Added XEP-0004 data forms parsing & serializing.
Diffstat (limited to '3rdParty/Boost/src/boost/variant/variant.hpp')
-rw-r--r--3rdParty/Boost/src/boost/variant/variant.hpp1862
1 files changed, 1862 insertions, 0 deletions
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