| //----------------------------------------------------------------------------- |
| // boost variant/variant.hpp header file |
| // See http://www.boost.org for updates, documentation, and revision history. |
| //----------------------------------------------------------------------------- |
| // |
| // Copyright (c) 2002-2003 |
| // Eric Friedman, Itay Maman |
| // |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| #ifndef BOOST_VARIANT_VARIANT_HPP |
| #define BOOST_VARIANT_VARIANT_HPP |
| |
| #include <cstddef> // for std::size_t |
| #include <new> // for placement new |
| |
| #if !defined(BOOST_NO_TYPEID) |
| #include <typeinfo> // for typeid, std::type_info |
| #endif // BOOST_NO_TYPEID |
| |
| #include "boost/variant/detail/config.hpp" |
| #include "boost/mpl/aux_/config/eti.hpp" |
| #include "boost/mpl/aux_/value_wknd.hpp" |
| |
| #include "boost/variant/variant_fwd.hpp" |
| #include "boost/variant/detail/backup_holder.hpp" |
| #include "boost/variant/detail/enable_recursive_fwd.hpp" |
| #include "boost/variant/detail/forced_return.hpp" |
| #include "boost/variant/detail/initializer.hpp" |
| #include "boost/variant/detail/make_variant_list.hpp" |
| #include "boost/variant/detail/over_sequence.hpp" |
| #include "boost/variant/detail/visitation_impl.hpp" |
| |
| #include "boost/variant/detail/generic_result_type.hpp" |
| #include "boost/variant/detail/has_nothrow_move.hpp" |
| #include "boost/variant/detail/move.hpp" |
| |
| #include "boost/detail/reference_content.hpp" |
| #include "boost/aligned_storage.hpp" |
| #include "boost/blank.hpp" |
| #include "boost/static_assert.hpp" |
| #include "boost/preprocessor/cat.hpp" |
| #include "boost/preprocessor/repeat.hpp" |
| #include "boost/type_traits/alignment_of.hpp" |
| #include "boost/type_traits/add_const.hpp" |
| #include "boost/type_traits/has_nothrow_constructor.hpp" |
| #include "boost/type_traits/has_nothrow_copy.hpp" |
| #include "boost/type_traits/is_const.hpp" |
| #include "boost/type_traits/is_same.hpp" |
| #include "boost/utility/enable_if.hpp" |
| #include "boost/variant/recursive_wrapper_fwd.hpp" |
| #include "boost/variant/static_visitor.hpp" |
| |
| #include "boost/mpl/eval_if.hpp" |
| #include "boost/mpl/begin_end.hpp" |
| #include "boost/mpl/bool.hpp" |
| #include "boost/mpl/not.hpp" |
| #include "boost/mpl/empty.hpp" |
| #include "boost/mpl/find_if.hpp" |
| #include "boost/mpl/front.hpp" |
| #include "boost/mpl/identity.hpp" |
| #include "boost/mpl/if.hpp" |
| #include "boost/mpl/int.hpp" |
| #include "boost/mpl/is_sequence.hpp" |
| #include "boost/mpl/iterator_range.hpp" |
| #include "boost/mpl/iter_fold_if.hpp" |
| #include "boost/mpl/logical.hpp" |
| #include "boost/mpl/max_element.hpp" |
| #include "boost/mpl/next.hpp" |
| #include "boost/mpl/deref.hpp" |
| #include "boost/mpl/pair.hpp" |
| #include "boost/mpl/protect.hpp" |
| #include "boost/mpl/push_front.hpp" |
| #include "boost/mpl/same_as.hpp" |
| #include "boost/mpl/size_t.hpp" |
| #include "boost/mpl/sizeof.hpp" |
| #include "boost/mpl/transform.hpp" |
| #include "boost/mpl/assert.hpp" |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Implementation Macros: |
| // |
| // BOOST_VARIANT_VISITATION_UNROLLING_LIMIT |
| // Defined in boost/variant/detail/visitation_impl.hpp. |
| // |
| // BOOST_VARIANT_MINIMIZE_SIZE |
| // When #defined, implementation employs all known means to minimize the |
| // size of variant obje cts. However, often unsuccessful due to alignment |
| // issues, and potentially harmful to runtime speed, so not enabled by |
| // default. (TODO: Investigate further.) |
| |
| #if defined(BOOST_VARIANT_MINIMIZE_SIZE) |
| # include <climits> // for SCHAR_MAX |
| # include "boost/mpl/eval_if.hpp" |
| # include "boost/mpl/equal_to.hpp" |
| # include "boost/mpl/identity.hpp" |
| # include "boost/mpl/int.hpp" |
| # include "boost/mpl/if.hpp" |
| # include "boost/mpl/less.hpp" |
| # include "boost/mpl/long.hpp" |
| # include "boost/mpl/O1_size.hpp" |
| #endif |
| |
| |
| namespace boost { |
| |
| namespace detail { namespace variant { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) metafunction max_value |
| // |
| // Finds the maximum value of the unary metafunction F over Sequence. |
| // |
| template <typename Sequence, typename F> |
| struct max_value |
| { |
| private: // helpers, for metafunction result (below) |
| |
| typedef typename mpl::transform1<Sequence, F>::type transformed_; |
| typedef typename mpl::max_element<transformed_ |
| |
| >::type max_it; |
| |
| public: // metafunction result |
| |
| typedef typename mpl::deref<max_it>::type |
| type; |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) metafunction find_fallback_type |
| // |
| // Provides a fallback (i.e., nothrow default-constructible) type from the |
| // specified sequence, or no_fallback_type if not found. |
| // |
| // This implementation is designed to prefer boost::blank over other potential |
| // fallback types, regardless of its position in the specified sequence. |
| // |
| |
| class no_fallback_type; |
| |
| struct find_fallback_type_pred |
| { |
| template <typename Iterator> |
| struct apply |
| { |
| private: |
| typedef typename mpl::deref<Iterator>::type t_; |
| |
| public: |
| typedef mpl::not_< has_nothrow_constructor<t_> > type; |
| }; |
| }; |
| |
| template <typename Types> |
| struct find_fallback_type |
| { |
| private: // helpers, for metafunction result (below) |
| |
| typedef typename mpl::end<Types>::type end_it; |
| |
| // [Find the first suitable fallback type...] |
| |
| typedef typename mpl::iter_fold_if< |
| Types |
| , mpl::int_<0>, mpl::protect< mpl::next<> > |
| , mpl::protect< find_fallback_type_pred > |
| >::type first_result_; |
| |
| typedef typename first_result_::first first_result_index; |
| typedef typename first_result_::second first_result_it; |
| |
| // [...now search the rest of the sequence for boost::blank...] |
| |
| typedef typename mpl::iter_fold_if< |
| mpl::iterator_range< first_result_it,end_it > |
| , first_result_index, mpl::protect< mpl::next<> > |
| , mpl::protect< mpl::not_same_as<boost::blank> > |
| >::type second_result_; |
| |
| typedef typename second_result_::second second_result_it; |
| |
| public: // metafunction result |
| |
| // [...and return the results of the search:] |
| typedef typename mpl::eval_if< |
| is_same< second_result_it,end_it > |
| , mpl::if_< |
| is_same< first_result_it,end_it > |
| , mpl::pair< no_fallback_type,no_fallback_type > |
| , first_result_ |
| > |
| , mpl::identity< second_result_ > |
| >::type type; |
| |
| }; |
| |
| #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) |
| |
| template<> |
| struct find_fallback_type<int> |
| { |
| typedef mpl::pair< no_fallback_type,no_fallback_type > type; |
| }; |
| |
| #endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) metafunction make_storage |
| // |
| // Provides an aligned storage type capable of holding any of the types |
| // specified in the given type-sequence. |
| // |
| |
| template <typename Types, typename NeverUsesBackupFlag> |
| struct make_storage |
| { |
| private: // helpers, for metafunction result (below) |
| |
| typedef typename mpl::eval_if< |
| NeverUsesBackupFlag |
| , mpl::identity< Types > |
| , mpl::push_front< |
| Types, backup_holder<void*> |
| > |
| >::type types; |
| |
| typedef typename max_value< |
| types, mpl::sizeof_<mpl::_1> |
| >::type max_size; |
| |
| #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) |
| |
| typedef typename max_value< |
| types, alignment_of<mpl::_1> |
| >::type max_alignment; |
| |
| #else // borland |
| |
| // temporary workaround -- use maximal alignment |
| typedef mpl::size_t< -1 > max_alignment; |
| |
| #endif // borland workaround |
| |
| public: // metafunction result |
| |
| #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| |
| typedef ::boost::aligned_storage< |
| BOOST_MPL_AUX_VALUE_WKND(max_size)::value |
| , BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value |
| > type; |
| |
| #else // MSVC7 and below |
| |
| BOOST_STATIC_CONSTANT(std::size_t, msvc_max_size_c = max_size::value); |
| BOOST_STATIC_CONSTANT(std::size_t, msvc_max_alignment_c = max_alignment::value); |
| |
| typedef ::boost::aligned_storage< |
| msvc_max_size_c |
| , msvc_max_alignment_c |
| > type; |
| |
| #endif // MSVC workaround |
| |
| }; |
| |
| #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) |
| |
| template<> |
| struct make_storage<int,int> |
| { |
| typedef int type; |
| }; |
| |
| #endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class destroyer |
| // |
| // Internal visitor that destroys the value it visits. |
| // |
| struct destroyer |
| : public static_visitor<> |
| { |
| public: // visitor interfaces |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(T& operand, int) const |
| { |
| operand.~T(); |
| |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) || \ |
| BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) |
| operand; // suppresses warnings |
| #endif |
| |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class template known_get |
| // |
| // Visitor that returns a reference to content of the specified type. |
| // |
| // Precondition: visited variant MUST contain logical content of type T. |
| // |
| template <typename T> |
| class known_get |
| : public static_visitor<T&> |
| { |
| |
| #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) |
| |
| public: // visitor interface |
| |
| T& operator()(T& operand) const |
| { |
| return operand; |
| } |
| |
| template <typename U> |
| T& operator()(U&) const |
| { |
| // logical error to be here: see precondition above |
| BOOST_ASSERT(false); |
| return ::boost::detail::variant::forced_return< T& >(); |
| } |
| |
| #else // MSVC6 |
| |
| private: // helpers, for visitor interface (below) |
| |
| T& execute(T& operand, mpl::true_) const |
| { |
| return operand; |
| } |
| |
| template <typename U> |
| T& execute(U& operand, mpl::false_) const |
| { |
| // logical error to be here: see precondition above |
| BOOST_ASSERT(false); |
| return ::boost::detail::variant::forced_return< T& >(); |
| } |
| |
| public: // visitor interface |
| |
| template <typename U> |
| T& operator()(U& operand) const |
| { |
| typedef typename is_same< U,T >::type |
| U_is_T; |
| |
| return execute(operand, U_is_T()); |
| } |
| |
| #endif // MSVC6 workaround |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class copy_into |
| // |
| // Internal visitor that copies the value it visits into the given buffer. |
| // |
| class copy_into |
| : public static_visitor<> |
| { |
| private: // representation |
| |
| void* storage_; |
| |
| public: // structors |
| |
| explicit copy_into(void* storage) |
| : storage_(storage) |
| { |
| } |
| |
| public: // internal visitor interface |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const |
| { |
| new(storage_) T( operand.get() ); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const |
| { |
| new(storage_) T( operand.get() ); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(const T& operand, int) const |
| { |
| new(storage_) T(operand); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class assign_storage |
| // |
| // Internal visitor that assigns the given storage (which must be a |
| // constructed value of the same type) to the value it visits. |
| // |
| struct assign_storage |
| : public static_visitor<> |
| { |
| private: // representation |
| |
| const void* rhs_storage_; |
| |
| public: // structors |
| |
| explicit assign_storage(const void* rhs_storage) |
| : rhs_storage_(rhs_storage) |
| { |
| } |
| |
| public: // internal visitor interfaces |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(backup_holder<T>& lhs_content, long) const |
| { |
| lhs_content.get() |
| = static_cast< const backup_holder<T>* >(rhs_storage_)->get(); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(const backup_holder<T>& lhs_content, long) const |
| { |
| lhs_content.get() |
| = static_cast< const backup_holder<T>* >(rhs_storage_)->get(); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(T& lhs_content, int) const |
| { |
| // NOTE TO USER : |
| // Compile error here indicates one of variant's bounded types does |
| // not meet the requirements of the Assignable concept. Thus, |
| // variant is not Assignable. |
| // |
| // Hint: Are any of the bounded types const-qualified or references? |
| // |
| lhs_content = *static_cast< const T* >(rhs_storage_); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class direct_assigner |
| // |
| // Generic static visitor that: if and only if the visited value is of the |
| // specified type, assigns the given value to the visited value and returns |
| // true; else returns false. |
| // |
| template <typename T> |
| class direct_assigner |
| : public static_visitor<bool> |
| { |
| private: // representation |
| |
| const T& rhs_; |
| |
| public: // structors |
| |
| explicit direct_assigner(const T& rhs) |
| : rhs_(rhs) |
| { |
| } |
| |
| #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) |
| |
| public: // visitor interface |
| |
| bool operator()(T& lhs) |
| { |
| lhs = rhs_; |
| return true; |
| } |
| |
| template <typename U> |
| bool operator()(U&) |
| { |
| return false; |
| } |
| |
| #else // MSVC6 |
| |
| private: // helpers, for visitor interface (below) |
| |
| bool execute(T& lhs, mpl::true_) |
| { |
| lhs = rhs_; |
| return true; |
| } |
| |
| template <typename U> |
| bool execute(U&, mpl::false_) |
| { |
| return false; |
| } |
| |
| public: // visitor interface |
| |
| template <typename U> |
| bool operator()(U& lhs) |
| { |
| typedef typename is_same<U,T>::type U_is_T; |
| return execute(lhs, U_is_T()); |
| } |
| |
| #endif // MSVC6 workaround |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) |
| private: |
| // silence MSVC warning C4512: assignment operator could not be generated |
| direct_assigner& operator= (direct_assigner const&); |
| #endif |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class backup_assigner |
| // |
| // Internal visitor that "assigns" the given value to the visited value, |
| // using backup to recover if the destroy-copy sequence fails. |
| // |
| // NOTE: This needs to be a friend of variant, as it needs access to |
| // indicate_which, indicate_backup_which, etc. |
| // |
| template <typename Variant, typename RhsT> |
| class backup_assigner |
| : public static_visitor<> |
| { |
| private: // representation |
| |
| Variant& lhs_; |
| int rhs_which_; |
| const RhsT& rhs_content_; |
| |
| public: // structors |
| |
| backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content) |
| : lhs_(lhs) |
| , rhs_which_(rhs_which) |
| , rhs_content_(rhs_content) |
| { |
| } |
| |
| private: // helpers, for visitor interface (below) |
| |
| template <typename LhsT> |
| void backup_assign_impl( |
| LhsT& lhs_content |
| , mpl::true_// has_nothrow_move |
| ) |
| { |
| // Move lhs content to backup... |
| LhsT backup_lhs_content( |
| ::boost::detail::variant::move(lhs_content) |
| ); // nothrow |
| |
| // ...destroy lhs content... |
| lhs_content.~LhsT(); // nothrow |
| |
| try |
| { |
| // ...and attempt to copy rhs content into lhs storage: |
| new(lhs_.storage_.address()) RhsT(rhs_content_); |
| } |
| catch (...) |
| { |
| // In case of failure, restore backup content to lhs storage... |
| new(lhs_.storage_.address()) |
| LhsT( |
| ::boost::detail::variant::move(backup_lhs_content) |
| ); // nothrow |
| |
| // ...and rethrow: |
| throw; |
| } |
| |
| // In case of success, indicate new content type: |
| lhs_.indicate_which(rhs_which_); // nothrow |
| } |
| |
| template <typename LhsT> |
| void backup_assign_impl( |
| LhsT& lhs_content |
| , mpl::false_// has_nothrow_move |
| ) |
| { |
| // Backup lhs content... |
| LhsT* backup_lhs_ptr = new LhsT(lhs_content); |
| |
| // ...destroy lhs content... |
| lhs_content.~LhsT(); // nothrow |
| |
| try |
| { |
| // ...and attempt to copy rhs content into lhs storage: |
| new(lhs_.storage_.address()) RhsT(rhs_content_); |
| } |
| catch (...) |
| { |
| // In case of failure, copy backup pointer to lhs storage... |
| new(lhs_.storage_.address()) |
| backup_holder<LhsT>( backup_lhs_ptr ); // nothrow |
| |
| // ...indicate now using backup... |
| lhs_.indicate_backup_which( lhs_.which() ); // nothrow |
| |
| // ...and rethrow: |
| throw; |
| } |
| |
| // In case of success, indicate new content type... |
| lhs_.indicate_which(rhs_which_); // nothrow |
| |
| // ...and delete backup: |
| delete backup_lhs_ptr; // nothrow |
| } |
| |
| public: // visitor interface |
| |
| template <typename LhsT> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(LhsT& lhs_content, int) |
| { |
| typedef typename has_nothrow_move_constructor<LhsT>::type |
| nothrow_move; |
| |
| backup_assign_impl( lhs_content, nothrow_move() ); |
| |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) |
| private: |
| // silence MSVC warning C4512: assignment operator could not be generated |
| backup_assigner& operator= (backup_assigner const&); |
| #endif |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class swap_with |
| // |
| // Visitor that swaps visited value with content of given variant. |
| // |
| // Precondition: Given variant MUST have same logical type as visited value. |
| // |
| template <typename Variant> |
| struct swap_with |
| : public static_visitor<> |
| { |
| private: // representation |
| |
| Variant& toswap_; |
| |
| public: // structors |
| |
| explicit swap_with(Variant& toswap) |
| : toswap_(toswap) |
| { |
| } |
| |
| public: // internal visitor interfaces |
| |
| template <typename T> |
| void operator()(T& operand) const |
| { |
| // Since the precondition ensures types are same, get T... |
| known_get<T> getter; |
| T& other = toswap_.apply_visitor(getter); |
| |
| // ...and swap: |
| ::boost::detail::variant::move_swap( operand, other ); |
| } |
| |
| private: |
| swap_with& operator=(const swap_with&); |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class reflect |
| // |
| // Generic static visitor that performs a typeid on the value it visits. |
| // |
| |
| #if !defined(BOOST_NO_TYPEID) |
| |
| class reflect |
| : public static_visitor<const std::type_info&> |
| { |
| public: // visitor interfaces |
| |
| template <typename T> |
| const std::type_info& operator()(const T&) const |
| { |
| return typeid(T); |
| } |
| |
| }; |
| |
| #endif // BOOST_NO_TYPEID |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class comparer |
| // |
| // Generic static visitor that compares the content of the given lhs variant |
| // with the visited rhs content using Comp. |
| // |
| // Precondition: lhs.which() == rhs.which() |
| // |
| template <typename Variant, typename Comp> |
| class comparer |
| : public static_visitor<bool> |
| { |
| private: // representation |
| |
| const Variant& lhs_; |
| |
| public: // structors |
| |
| explicit comparer(const Variant& lhs) |
| : lhs_(lhs) |
| { |
| } |
| |
| public: // visitor interfaces |
| |
| template <typename T> |
| bool operator()(const T& rhs_content) const |
| { |
| // Since the precondition ensures lhs and rhs types are same, get T... |
| known_get<const T> getter; |
| const T& lhs_content = lhs_.apply_visitor(getter); |
| |
| // ...and compare lhs and rhs contents: |
| return Comp()(lhs_content, rhs_content); |
| } |
| |
| private: |
| comparer& operator=(const comparer&); |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class equal_comp |
| // |
| // Generic function object compares lhs with rhs using operator==. |
| // |
| struct equal_comp |
| { |
| template <typename T> |
| bool operator()(const T& lhs, const T& rhs) const |
| { |
| return lhs == rhs; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class less_comp |
| // |
| // Generic function object compares lhs with rhs using operator<. |
| // |
| struct less_comp |
| { |
| template <typename T> |
| bool operator()(const T& lhs, const T& rhs) const |
| { |
| return lhs < rhs; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) class template invoke_visitor |
| // |
| // Internal visitor that invokes the given visitor using: |
| // * for wrappers (e.g., recursive_wrapper), the wrapper's held value. |
| // * for all other values, the value itself. |
| // |
| template <typename Visitor> |
| class invoke_visitor |
| { |
| private: // representation |
| |
| Visitor& visitor_; |
| |
| public: // visitor typedefs |
| |
| typedef typename Visitor::result_type |
| result_type; |
| |
| public: // structors |
| |
| explicit invoke_visitor(Visitor& visitor) |
| : visitor_(visitor) |
| { |
| } |
| |
| #if !defined(BOOST_NO_VOID_RETURNS) |
| |
| public: // internal visitor interfaces |
| |
| template <typename T> |
| result_type internal_visit(T& operand, int) |
| { |
| return visitor_(operand); |
| } |
| |
| # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) |
| template <typename T> |
| result_type internal_visit(const T& operand, int) |
| { |
| return visitor_(operand); |
| } |
| # endif |
| |
| #else // defined(BOOST_NO_VOID_RETURNS) |
| |
| private: // helpers, for internal visitor interfaces (below) |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| visit_impl(T& operand, mpl::false_) |
| { |
| return visitor_(operand); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| visit_impl(T& operand, mpl::true_) |
| { |
| visitor_(operand); |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| public: // internal visitor interfaces |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(T& operand, int) |
| { |
| typedef typename is_same<result_type, void>::type |
| has_void_result_type; |
| |
| return visit_impl(operand, has_void_result_type()); |
| } |
| |
| #endif // BOOST_NO_VOID_RETURNS) workaround |
| |
| public: // internal visitor interfaces, cont. |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(boost::recursive_wrapper<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(const boost::recursive_wrapper<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(boost::detail::reference_content<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(const boost::detail::reference_content<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(boost::detail::variant::backup_holder<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) |
| internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) |
| private: |
| // silence MSVC warning C4512: assignment operator could not be generated |
| invoke_visitor& operator= (invoke_visitor const&); |
| #endif |
| }; |
| |
| }} // namespace detail::variant |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // class template variant (concept inspired by Andrei Alexandrescu) |
| // |
| // See docs and boost/variant/variant_fwd.hpp for more information. |
| // |
| template < |
| typename T0_ |
| , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T) |
| > |
| class variant |
| { |
| private: // helpers, for typedefs (below) |
| |
| typedef variant wknd_self_t; |
| |
| struct is_recursive_ |
| : detail::variant::is_recursive_flag<T0_> |
| { |
| }; |
| |
| typedef typename mpl::eval_if< |
| is_recursive_ |
| , T0_ |
| , mpl::identity< T0_ > |
| >::type unwrapped_T0_; |
| |
| struct is_sequence_based_ |
| : detail::variant::is_over_sequence<unwrapped_T0_> |
| { |
| }; |
| |
| #if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) |
| |
| private: // helpers, for typedefs (below) |
| |
| typedef typename mpl::eval_if< |
| is_sequence_based_ |
| , unwrapped_T0_ // over_sequence<...>::type |
| , detail::variant::make_variant_list< |
| unwrapped_T0_ |
| , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) |
| > |
| >::type specified_types; |
| |
| BOOST_STATIC_ASSERT(( |
| ::boost::mpl::not_< mpl::empty<specified_types> >::value |
| )); |
| |
| typedef typename mpl::eval_if< |
| is_recursive_ |
| , mpl::transform< |
| specified_types |
| , mpl::protect< |
| detail::variant::quoted_enable_recursive<wknd_self_t> |
| > |
| > |
| , mpl::identity< specified_types > |
| >::type recursive_enabled_types; |
| |
| public: // public typedefs |
| |
| typedef typename mpl::transform< |
| recursive_enabled_types |
| , unwrap_recursive<mpl::_1> |
| >::type types; |
| |
| private: // internal typedefs |
| |
| typedef typename mpl::transform< |
| recursive_enabled_types |
| , mpl::protect< detail::make_reference_content<> > |
| >::type internal_types; |
| |
| typedef typename mpl::front< |
| internal_types |
| >::type internal_T0; |
| |
| #else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) |
| |
| private: // helpers, for typedefs (below) |
| |
| typedef unwrapped_T0_ T0; |
| |
| #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \ |
| typedef typename mpl::eval_if< \ |
| is_recursive_ \ |
| , detail::variant::enable_recursive< \ |
| BOOST_PP_CAT(T,N) \ |
| , wknd_self_t \ |
| > \ |
| , mpl::identity< BOOST_PP_CAT(T,N) > \ |
| >::type BOOST_PP_CAT(recursive_enabled_T,N); \ |
| /**/ |
| |
| BOOST_PP_REPEAT( |
| BOOST_VARIANT_LIMIT_TYPES |
| , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS |
| , _ |
| ) |
| |
| #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS |
| |
| #define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \ |
| typedef typename unwrap_recursive< \ |
| BOOST_PP_CAT(recursive_enabled_T,N) \ |
| >::type BOOST_PP_CAT(public_T,N); \ |
| /**/ |
| |
| BOOST_PP_REPEAT( |
| BOOST_VARIANT_LIMIT_TYPES |
| , BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS |
| , _ |
| ) |
| |
| #undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS |
| |
| public: // public typedefs |
| |
| typedef typename detail::variant::make_variant_list< |
| BOOST_VARIANT_ENUM_PARAMS(public_T) |
| >::type types; |
| |
| private: // helpers, for internal typedefs (below) |
| |
| #define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \ |
| typedef detail::make_reference_content< \ |
| BOOST_PP_CAT(recursive_enabled_T,N) \ |
| >::type BOOST_PP_CAT(internal_T,N); \ |
| /**/ |
| |
| BOOST_PP_REPEAT( |
| BOOST_VARIANT_LIMIT_TYPES |
| , BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS |
| , _ |
| ) |
| |
| #undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS |
| |
| private: // internal typedefs |
| |
| typedef typename detail::variant::make_variant_list< |
| BOOST_VARIANT_ENUM_PARAMS(internal_T) |
| >::type internal_types; |
| |
| private: // static precondition assertions |
| |
| // NOTE TO USER : |
| // variant< type-sequence > syntax is not supported on this compiler! |
| // |
| BOOST_MPL_ASSERT_NOT(( is_sequence_based_ )); |
| |
| #endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround |
| |
| private: // helpers, for representation (below) |
| |
| typedef typename detail::variant::find_fallback_type< |
| internal_types |
| >::type fallback_type_result_; |
| |
| typedef typename fallback_type_result_::first |
| fallback_type_index_; |
| typedef typename fallback_type_result_::second |
| fallback_type_; |
| |
| struct has_fallback_type_ |
| : mpl::not_< |
| is_same< fallback_type_, detail::variant::no_fallback_type > |
| > |
| { |
| }; |
| |
| typedef has_fallback_type_ |
| never_uses_backup_flag; |
| |
| typedef typename detail::variant::make_storage< |
| internal_types, never_uses_backup_flag |
| >::type storage_t; |
| |
| private: // helpers, for representation (below) |
| |
| // which_ on: |
| // * [0, size<internal_types>) indicates stack content |
| // * [-size<internal_types>, 0) indicates pointer to heap backup |
| // if which_ >= 0: |
| // * then which() -> which_ |
| // * else which() -> -(which_ + 1) |
| |
| #if !defined(BOOST_VARIANT_MINIMIZE_SIZE) |
| |
| typedef int which_t; |
| |
| #else // defined(BOOST_VARIANT_MINIMIZE_SIZE) |
| |
| // [if O1_size available, then attempt which_t size optimization...] |
| // [select signed char if fewer than SCHAR_MAX types, else signed int:] |
| typedef typename mpl::eval_if< |
| mpl::equal_to< mpl::O1_size<internal_types>, mpl::long_<-1> > |
| , mpl::identity< int > |
| , mpl::if_< |
| mpl::less< mpl::O1_size<internal_types>, mpl::int_<SCHAR_MAX> > |
| , signed char |
| , int |
| > |
| >::type which_t; |
| |
| #endif // BOOST_VARIANT_MINIMIZE_SIZE switch |
| |
| // representation -- private when possible |
| #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) |
| private: |
| #else |
| public: |
| #endif |
| |
| which_t which_; |
| storage_t storage_; |
| |
| void indicate_which(int which) |
| { |
| which_ = static_cast<which_t>( which ); |
| } |
| |
| void indicate_backup_which(int which) |
| { |
| which_ = static_cast<which_t>( -(which + 1) ); |
| } |
| |
| private: // helpers, for queries (below) |
| |
| bool using_backup() const |
| { |
| return which_ < 0; |
| } |
| |
| public: // queries |
| |
| int which() const |
| { |
| // If using heap backup... |
| if (using_backup()) |
| // ...then return adjusted which_: |
| return -(which_ + 1); |
| |
| // Otherwise, return which_ directly: |
| return which_; |
| } |
| |
| private: // helpers, for structors (below) |
| |
| struct initializer |
| : BOOST_VARIANT_AUX_INITIALIZER_T( |
| recursive_enabled_types, recursive_enabled_T |
| ) |
| { |
| }; |
| |
| void destroy_content() |
| { |
| detail::variant::destroyer visitor; |
| this->internal_apply_visitor(visitor); |
| } |
| |
| public: // structors |
| |
| ~variant() |
| { |
| destroy_content(); |
| } |
| |
| variant() |
| { |
| // NOTE TO USER : |
| // Compile error from here indicates that the first bound |
| // type is not default-constructible, and so variant cannot |
| // support its own default-construction. |
| // |
| new( storage_.address() ) internal_T0(); |
| indicate_which(0); // zero is the index of the first bounded type |
| } |
| |
| private: // helpers, for structors, cont. (below) |
| |
| class convert_copy_into |
| : public static_visitor<int> |
| { |
| private: // representation |
| |
| void* storage_; |
| |
| public: // structors |
| |
| explicit convert_copy_into(void* storage) |
| : storage_(storage) |
| { |
| } |
| |
| public: // internal visitor interfaces (below) |
| |
| template <typename T> |
| int internal_visit(T& operand, int) const |
| { |
| // NOTE TO USER : |
| // Compile error here indicates one of the source variant's types |
| // cannot be unambiguously converted to the destination variant's |
| // types (or that no conversion exists). |
| // |
| return initializer::initialize(storage_, operand); |
| } |
| |
| # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) |
| template <typename T> |
| result_type internal_visit(const T& operand, int) const |
| { |
| return initializer::initialize(storage_, operand); |
| } |
| # endif |
| |
| template <typename T> |
| int internal_visit(boost::detail::reference_content<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| int internal_visit(const boost::detail::reference_content<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| int internal_visit(boost::recursive_wrapper<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| template <typename T> |
| int internal_visit(const boost::recursive_wrapper<T>& operand, long) const |
| { |
| return internal_visit( operand.get(), 1L ); |
| } |
| |
| }; |
| |
| friend class convert_copy_into; |
| |
| private: // helpers, for structors, below |
| |
| template <typename T> |
| void convert_construct( |
| T& operand |
| , int |
| , mpl::false_ = mpl::false_() // is_foreign_variant |
| ) |
| { |
| // NOTE TO USER : |
| // Compile error here indicates that the given type is not |
| // unambiguously convertible to one of the variant's types |
| // (or that no conversion exists). |
| // |
| indicate_which( |
| initializer::initialize( |
| storage_.address() |
| , operand |
| ) |
| ); |
| } |
| |
| template <typename Variant> |
| void convert_construct( |
| Variant& operand |
| , long |
| , mpl::true_// is_foreign_variant |
| ) |
| { |
| convert_copy_into visitor(storage_.address()); |
| indicate_which( |
| operand.internal_apply_visitor(visitor) |
| ); |
| } |
| |
| template <typename Variant> |
| void convert_construct_variant(Variant& operand) |
| { |
| // [Determine if the given variant is itself a bounded type, or if its |
| // content needs to be converted (i.e., it is a 'foreign' variant):] |
| // |
| |
| typedef typename mpl::find_if< |
| types |
| , is_same< |
| add_const<mpl::_1> |
| , const Variant |
| > |
| >::type found_it; |
| |
| typedef typename mpl::end<types>::type not_found; |
| typedef typename is_same< |
| found_it, not_found |
| >::type is_foreign_variant; |
| |
| // Convert construct from operand: |
| convert_construct( |
| operand, 1L |
| , is_foreign_variant() |
| ); |
| } |
| |
| template <BOOST_VARIANT_ENUM_PARAMS(typename U)> |
| void convert_construct( |
| boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand |
| , long |
| ) |
| { |
| convert_construct_variant(operand); |
| } |
| |
| template <BOOST_VARIANT_ENUM_PARAMS(typename U)> |
| void convert_construct( |
| const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand |
| , long |
| ) |
| { |
| convert_construct_variant(operand); |
| } |
| |
| public: // structors, cont. |
| |
| #if !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) |
| |
| template <typename T> |
| variant(const T& operand) |
| { |
| convert_construct(operand, 1L); |
| } |
| |
| template <typename T> |
| variant(T& operand) |
| { |
| convert_construct(operand, 1L); |
| } |
| |
| #elif defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) |
| |
| // For compilers that cannot distinguish between T& and const T& in |
| // template constructors, but do fully support SFINAE, we can workaround: |
| |
| template <typename T> |
| variant(const T& operand) |
| { |
| convert_construct(operand, 1L); |
| } |
| |
| template <typename T> |
| variant( |
| T& operand |
| , typename enable_if< |
| mpl::not_< is_const<T> > |
| , void |
| >::type* = 0 |
| ) |
| { |
| convert_construct(operand, 1L); |
| } |
| |
| #else // !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) |
| |
| // For compilers that cannot distinguish between T& and const T& in |
| // template constructors, and do NOT support SFINAE, we can't workaround: |
| |
| template <typename T> |
| variant(const T& operand) |
| { |
| convert_construct(operand, 1L); |
| } |
| |
| #endif // BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING workarounds |
| |
| public: // structors, cont. |
| |
| // [MSVC6 requires copy constructor appear after template constructors] |
| variant(const variant& operand) |
| { |
| // Copy the value of operand into *this... |
| detail::variant::copy_into visitor( storage_.address() ); |
| operand.internal_apply_visitor(visitor); |
| |
| // ...and activate the *this's primary storage on success: |
| indicate_which(operand.which()); |
| } |
| |
| private: // helpers, for modifiers (below) |
| |
| # if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) |
| template <typename Variant, typename RhsT> |
| friend class detail::variant::backup_assigner; |
| # endif |
| |
| // class assigner |
| // |
| // Internal visitor that "assigns" the visited value to the given variant |
| // by appropriate destruction and copy-construction. |
| // |
| |
| class assigner |
| : public static_visitor<> |
| { |
| private: // representation |
| |
| variant& lhs_; |
| int rhs_which_; |
| |
| public: // structors |
| |
| assigner(variant& lhs, int rhs_which) |
| : lhs_(lhs) |
| , rhs_which_(rhs_which) |
| { |
| } |
| |
| private: // helpers, for internal visitor interface (below) |
| |
| template <typename RhsT, typename B1, typename B2> |
| void assign_impl( |
| const RhsT& rhs_content |
| , mpl::true_// has_nothrow_copy |
| , B1// has_nothrow_move_constructor |
| , B2// has_fallback_type |
| ) |
| { |
| // Destroy lhs's content... |
| lhs_.destroy_content(); // nothrow |
| |
| // ...copy rhs content into lhs's storage... |
| new(lhs_.storage_.address()) |
| RhsT( rhs_content ); // nothrow |
| |
| // ...and indicate new content type: |
| lhs_.indicate_which(rhs_which_); // nothrow |
| } |
| |
| template <typename RhsT, typename B> |
| void assign_impl( |
| const RhsT& rhs_content |
| , mpl::false_// has_nothrow_copy |
| , mpl::true_// has_nothrow_move_constructor |
| , B// has_fallback_type |
| ) |
| { |
| // Attempt to make a temporary copy (so as to move it below)... |
| RhsT temp(rhs_content); |
| |
| // ...and upon success destroy lhs's content... |
| lhs_.destroy_content(); // nothrow |
| |
| // ...move the temporary copy into lhs's storage... |
| new(lhs_.storage_.address()) |
| RhsT( detail::variant::move(temp) ); // nothrow |
| |
| // ...and indicate new content type: |
| lhs_.indicate_which(rhs_which_); // nothrow |
| } |
| |
| template <typename RhsT> |
| void assign_impl( |
| const RhsT& rhs_content |
| , mpl::false_// has_nothrow_copy |
| , mpl::false_// has_nothrow_move_constructor |
| , mpl::true_// has_fallback_type |
| ) |
| { |
| // Destroy lhs's content... |
| lhs_.destroy_content(); // nothrow |
| |
| try |
| { |
| // ...and attempt to copy rhs's content into lhs's storage: |
| new(lhs_.storage_.address()) |
| RhsT( rhs_content ); |
| } |
| catch (...) |
| { |
| // In case of failure, default-construct fallback type in lhs's storage... |
| new (lhs_.storage_.address()) |
| fallback_type_; // nothrow |
| |
| // ...indicate construction of fallback type... |
| lhs_.indicate_which( |
| BOOST_MPL_AUX_VALUE_WKND(fallback_type_index_)::value |
| ); // nothrow |
| |
| // ...and rethrow: |
| throw; |
| } |
| |
| // In the event of success, indicate new content type: |
| lhs_.indicate_which(rhs_which_); // nothrow |
| } |
| |
| template <typename RhsT> |
| void assign_impl( |
| const RhsT& rhs_content |
| , mpl::false_// has_nothrow_copy |
| , mpl::false_// has_nothrow_move_constructor |
| , mpl::false_// has_fallback_type |
| ) |
| { |
| detail::variant::backup_assigner<wknd_self_t, RhsT> |
| visitor(lhs_, rhs_which_, rhs_content); |
| lhs_.internal_apply_visitor(visitor); |
| } |
| |
| public: // internal visitor interfaces |
| |
| template <typename RhsT> |
| BOOST_VARIANT_AUX_RETURN_VOID_TYPE |
| internal_visit(const RhsT& rhs_content, int) |
| { |
| typedef typename has_nothrow_copy<RhsT>::type |
| nothrow_copy; |
| typedef typename mpl::or_< // reduces compile-time |
| nothrow_copy |
| , detail::variant::has_nothrow_move_constructor<RhsT> |
| >::type nothrow_move_constructor; |
| |
| assign_impl( |
| rhs_content |
| , nothrow_copy() |
| , nothrow_move_constructor() |
| , has_fallback_type_() |
| ); |
| |
| BOOST_VARIANT_AUX_RETURN_VOID; |
| } |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) |
| private: |
| // silence MSVC warning C4512: assignment operator could not be generated |
| assigner& operator= (assigner const&); |
| #endif |
| }; |
| |
| friend class assigner; |
| |
| void variant_assign(const variant& rhs) |
| { |
| // If the contained types are EXACTLY the same... |
| if (which_ == rhs.which_) |
| { |
| // ...then assign rhs's storage to lhs's content: |
| detail::variant::assign_storage visitor(rhs.storage_.address()); |
| this->internal_apply_visitor(visitor); |
| } |
| else |
| { |
| // Otherwise, perform general (copy-based) variant assignment: |
| assigner visitor(*this, rhs.which()); |
| rhs.internal_apply_visitor(visitor); |
| } |
| } |
| |
| private: // helpers, for modifiers (below) |
| |
| template <typename T> |
| void assign(const T& rhs) |
| { |
| // If direct T-to-T assignment is not possible... |
| detail::variant::direct_assigner<T> direct_assign(rhs); |
| if (this->apply_visitor(direct_assign) == false) |
| { |
| // ...then convert rhs to variant and assign: |
| // |
| // While potentially inefficient, the following construction of a |
| // variant allows T as any type convertible to one of the bounded |
| // types without excessive code redundancy. |
| // |
| variant temp(rhs); |
| variant_assign( detail::variant::move(temp) ); |
| } |
| } |
| |
| public: // modifiers |
| |
| template <typename T> |
| variant& operator=(const T& rhs) |
| { |
| assign(rhs); |
| return *this; |
| } |
| |
| // [MSVC6 requires copy assign appear after templated operator=] |
| variant& operator=(const variant& rhs) |
| { |
| variant_assign(rhs); |
| return *this; |
| } |
| |
| void swap(variant& rhs) |
| { |
| // If the contained types are the same... |
| if (which() == rhs.which()) |
| { |
| // ...then swap the values directly: |
| detail::variant::swap_with<variant> visitor(rhs); |
| this->apply_visitor(visitor); |
| } |
| else |
| { |
| // ...otherwise, perform general variant swap: |
| variant tmp( detail::variant::move(rhs) ); |
| rhs = detail::variant::move(*this); |
| *this = detail::variant::move(tmp); |
| } |
| } |
| |
| public: // queries |
| |
| // |
| // NOTE: member which() defined above. |
| // |
| |
| bool empty() const |
| { |
| return false; |
| } |
| |
| #if !defined(BOOST_NO_TYPEID) |
| const std::type_info& type() const |
| { |
| detail::variant::reflect visitor; |
| return this->apply_visitor(visitor); |
| } |
| #endif |
| |
| public: // prevent comparison with foreign types |
| |
| #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| |
| # define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \ |
| void |
| |
| #else // MSVC7 |
| |
| // |
| // MSVC7 gives error about return types for above being different than |
| // the true comparison operator overloads: |
| // |
| |
| # define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \ |
| bool |
| |
| #endif // MSVC7 workaround |
| |
| template <typename U> |
| BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE |
| operator==(const U&) const |
| { |
| BOOST_STATIC_ASSERT( false && sizeof(U) ); |
| } |
| |
| template <typename U> |
| BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE |
| operator<(const U&) const |
| { |
| BOOST_STATIC_ASSERT( false && sizeof(U) ); |
| } |
| |
| public: // comparison operators |
| |
| // [MSVC6 requires these operators appear after template operators] |
| |
| bool operator==(const variant& rhs) const |
| { |
| if (this->which() != rhs.which()) |
| return false; |
| |
| detail::variant::comparer< |
| variant, detail::variant::equal_comp |
| > visitor(*this); |
| return rhs.apply_visitor(visitor); |
| } |
| |
| bool operator<(const variant& rhs) const |
| { |
| // |
| // Dirk Schreib suggested this collating order. |
| // |
| |
| if (this->which() != rhs.which()) |
| return this->which() < rhs.which(); |
| |
| detail::variant::comparer< |
| variant, detail::variant::less_comp |
| > visitor(*this); |
| return rhs.apply_visitor(visitor); |
| } |
| |
| // helpers, for visitation support (below) -- private when possible |
| #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) |
| |
| template < BOOST_VARIANT_ENUM_PARAMS(typename U) > |
| friend class variant; |
| |
| private: |
| |
| #else// defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) |
| |
| public: |
| |
| #endif// !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) |
| |
| template <typename Visitor, typename VoidPtrCV> |
| static |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( |
| typename Visitor::result_type |
| ) |
| internal_apply_visitor_impl( |
| int internal_which |
| , int logical_which |
| , Visitor& visitor |
| , VoidPtrCV storage |
| ) |
| { |
| typedef mpl::int_<0> first_which; |
| typedef typename mpl::begin<internal_types>::type first_it; |
| typedef typename mpl::end<internal_types>::type last_it; |
| |
| typedef detail::variant::visitation_impl_step< |
| first_it, last_it |
| > first_step; |
| |
| return detail::variant::visitation_impl( |
| internal_which, logical_which |
| , visitor, storage, mpl::false_() |
| , never_uses_backup_flag() |
| , static_cast<first_which*>(0), static_cast<first_step*>(0) |
| ); |
| } |
| |
| template <typename Visitor> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( |
| typename Visitor::result_type |
| ) |
| internal_apply_visitor(Visitor& visitor) |
| { |
| return internal_apply_visitor_impl( |
| which_, which(), visitor, storage_.address() |
| ); |
| } |
| |
| template <typename Visitor> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( |
| typename Visitor::result_type |
| ) |
| internal_apply_visitor(Visitor& visitor) const |
| { |
| return internal_apply_visitor_impl( |
| which_, which(), visitor, storage_.address() |
| ); |
| } |
| |
| public: // visitation support |
| |
| template <typename Visitor> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( |
| typename Visitor::result_type |
| ) |
| apply_visitor(Visitor& visitor) |
| { |
| detail::variant::invoke_visitor<Visitor> invoker(visitor); |
| return this->internal_apply_visitor(invoker); |
| } |
| |
| template <typename Visitor> |
| BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( |
| typename Visitor::result_type |
| ) |
| apply_visitor(Visitor& visitor) const |
| { |
| detail::variant::invoke_visitor<Visitor> invoker(visitor); |
| return this->internal_apply_visitor(invoker); |
| } |
| |
| }; // class variant |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // metafunction make_variant_over |
| // |
| // See docs and boost/variant/variant_fwd.hpp for more information. |
| // |
| template <typename Types> |
| struct make_variant_over |
| { |
| private: // precondition assertions |
| |
| #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value )); |
| #endif |
| |
| public: // metafunction result |
| |
| typedef variant< |
| detail::variant::over_sequence< Types > |
| > type; |
| |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // function template swap |
| // |
| // Swaps two variants of the same type (i.e., identical specification). |
| // |
| template < BOOST_VARIANT_ENUM_PARAMS(typename T) > |
| inline void swap( |
| variant< BOOST_VARIANT_ENUM_PARAMS(T) >& lhs |
| , variant< BOOST_VARIANT_ENUM_PARAMS(T) >& rhs |
| ) |
| { |
| lhs.swap(rhs); |
| } |
| |
| } // namespace boost |
| |
| // implementation additions |
| |
| #if !defined(BOOST_NO_IOSTREAM) |
| #include "boost/variant/detail/variant_io.hpp" |
| #endif // BOOST_NO_IOSTREAM |
| |
| #endif // BOOST_VARIANT_VARIANT_HPP |