//-----------------------------------------------------------------------------

 // 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)

 /*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 */

 #ifndef BOOST_VARIANT_VARIANT_HPP

 #define BOOST_VARIANT_VARIANT_HPP

 #include <cstddef> // for std::size_t

 #include <new> // for placement new

 #ifdef __SYMBIAN32__

 #include <string>

 #endif

 #include <typeinfo> // for typeid, std::type_info

 #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))

         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

     T& rhs_;

 public: // structors

     explicit direct_assigner(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

 };

 ///////////////////////////////////////////////////////////////////////////////

 // (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;

     }

 };

 ///////////////////////////////////////////////////////////////////////////////

 // (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.

 //

 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);

     }

 };

 ///////////////////////////////////////////////////////////////////////////////

 // (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 );

     }

 };

 }} // 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;

         }

     };

     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<const 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;

     }

     const std::type_info& type() const

     {

         detail::variant::reflect visitor;

         return this->apply_visitor(visitor);

     }

 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

 #include "boost/variant/detail/variant_io.hpp"

 #endif // BOOST_VARIANT_VARIANT_HPP