--- a/epoc32/include/stdapis/boost/variant.hpp Wed Mar 31 12:27:01 2010 +0100
+++ b/epoc32/include/stdapis/boost/variant.hpp Wed Mar 31 12:33:34 2010 +0100
@@ -1,1833 +1,27 @@
//-----------------------------------------------------------------------------
-// boost variant/variant.hpp header file
+// boost variant.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
-// Copyright (c) 2002-2003
+// Copyright (c) 2003
// Eric Friedman, Itay Maman
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-/*
- * © 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_>
- {
- };
+#ifndef BOOST_VARIANT_HPP
+#define BOOST_VARIANT_HPP
- 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);
- }
+// variant "main"
+#include "boost/variant/variant.hpp"
+#include "boost/variant/recursive_variant.hpp"
+#include "boost/variant/recursive_wrapper.hpp"
-#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;
- }
+// common applications
+#include "boost/variant/get.hpp"
+#include "boost/variant/apply_visitor.hpp"
+#include "boost/variant/static_visitor.hpp"
+#include "boost/variant/visitor_ptr.hpp"
- 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
+#endif // BOOST_VARIANT_HPP