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

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