2 // boost variant/variant.hpp header file

     2 // boost variant.hpp header file

     6 // Copyright (c) 2002-2003

     6 // Copyright (c) 2003

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

    13 #ifndef BOOST_VARIANT_HPP

    19 #include <new> // for placement new

    14 #define BOOST_VARIANT_HPP

    20 #ifdef __SYMBIAN32__

    21 #include <string>

    22 #endif

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

    25 #include "boost/variant/detail/config.hpp"

    16 // variant "main"

    26 #include "boost/mpl/aux_/config/eti.hpp"

    17 #include "boost/variant/variant.hpp"

    27 #include "boost/mpl/aux_/value_wknd.hpp"

    18 #include "boost/variant/recursive_variant.hpp"

    19 #include "boost/variant/recursive_wrapper.hpp"

    29 #include "boost/variant/variant_fwd.hpp"

    21 // common applications

    30 #include "boost/variant/detail/backup_holder.hpp"

    22 #include "boost/variant/get.hpp"

    31 #include "boost/variant/detail/enable_recursive_fwd.hpp"

    23 #include "boost/variant/apply_visitor.hpp"

    32 #include "boost/variant/detail/forced_return.hpp"

    24 #include "boost/variant/static_visitor.hpp"

    33 #include "boost/variant/detail/initializer.hpp"

    25 #include "boost/variant/visitor_ptr.hpp"

    34 #include "boost/variant/detail/make_variant_list.hpp"

    35 #include "boost/variant/detail/over_sequence.hpp"

    36 #include "boost/variant/detail/visitation_impl.hpp"

    38 #include "boost/variant/detail/generic_result_type.hpp"

    27 #endif // BOOST_VARIANT_HPP

    39 #include "boost/variant/detail/has_nothrow_move.hpp"

    40 #include "boost/variant/detail/move.hpp"

    41 

    42 #include "boost/detail/reference_content.hpp"

    43 #include "boost/aligned_storage.hpp"

    44 #include "boost/blank.hpp"

    45 #include "boost/static_assert.hpp"

    46 #include "boost/preprocessor/cat.hpp"

    47 #include "boost/preprocessor/repeat.hpp"

    48 #include "boost/type_traits/alignment_of.hpp"

    49 #include "boost/type_traits/add_const.hpp"

    50 #include "boost/type_traits/has_nothrow_constructor.hpp"

    51 #include "boost/type_traits/has_nothrow_copy.hpp"

    52 #include "boost/type_traits/is_const.hpp"

    53 #include "boost/type_traits/is_same.hpp"

    54 #include "boost/utility/enable_if.hpp"

    55 #include "boost/variant/recursive_wrapper_fwd.hpp"

    56 #include "boost/variant/static_visitor.hpp"

    57 

    58 #include "boost/mpl/eval_if.hpp"

    59 #include "boost/mpl/begin_end.hpp"

    60 #include "boost/mpl/bool.hpp"

    61 #include "boost/mpl/empty.hpp"

    62 #include "boost/mpl/find_if.hpp"

    63 #include "boost/mpl/front.hpp"

    64 #include "boost/mpl/identity.hpp"

    65 #include "boost/mpl/if.hpp"

    66 #include "boost/mpl/int.hpp"

    67 #include "boost/mpl/is_sequence.hpp"

    68 #include "boost/mpl/iterator_range.hpp"

    69 #include "boost/mpl/iter_fold_if.hpp"

    70 #include "boost/mpl/logical.hpp"

    71 #include "boost/mpl/max_element.hpp"

    72 #include "boost/mpl/next.hpp"

    73 #include "boost/mpl/deref.hpp"

    74 #include "boost/mpl/pair.hpp"

    75 #include "boost/mpl/protect.hpp"

    76 #include "boost/mpl/push_front.hpp"

    77 #include "boost/mpl/same_as.hpp"

    78 #include "boost/mpl/size_t.hpp"

    79 #include "boost/mpl/sizeof.hpp"

    80 #include "boost/mpl/transform.hpp"

    81 #include "boost/mpl/assert.hpp"

    82 

    83 ///////////////////////////////////////////////////////////////////////////////

    84 // Implementation Macros:

    85 //

    86 // BOOST_VARIANT_VISITATION_UNROLLING_LIMIT

    87 //   Defined in boost/variant/detail/visitation_impl.hpp.

    88 //

    89 // BOOST_VARIANT_MINIMIZE_SIZE

    90 //   When #defined, implementation employs all known means to minimize the

    91 //   size of variant obje   cts. However, often unsuccessful due to alignment

    92 //   issues, and potentially harmful to runtime speed, so not enabled by

    93 //   default. (TODO: Investigate further.)

    94 

    95 #if defined(BOOST_VARIANT_MINIMIZE_SIZE)

    96 #   include <climits> // for SCHAR_MAX

    97 #   include "boost/mpl/eval_if.hpp"

    98 #   include "boost/mpl/equal_to.hpp"

    99 #   include "boost/mpl/identity.hpp"

   100 #   include "boost/mpl/int.hpp"

   101 #   include "boost/mpl/if.hpp"

   102 #   include "boost/mpl/less.hpp"

   103 #   include "boost/mpl/long.hpp"

   104 #   include "boost/mpl/O1_size.hpp"

   105 #endif

   106 

   107 

   108 namespace boost {

   109 

   110 namespace detail { namespace variant {

   111 

   112 ///////////////////////////////////////////////////////////////////////////////

   113 // (detail) metafunction max_value

   114 //

   115 // Finds the maximum value of the unary metafunction F over Sequence.

   116 //

   117 template <typename Sequence, typename F>

   118 struct max_value

   119 {

   120 private: // helpers, for metafunction result (below)

   121 

   122     typedef typename mpl::transform1<Sequence, F>::type transformed_;

   123     typedef typename mpl::max_element<transformed_

   124           

   125         >::type max_it;

   126 

   127 public: // metafunction result

   128 

   129     typedef typename mpl::deref<max_it>::type

   130         type;

   131 

   132 };

   133 

   134 ///////////////////////////////////////////////////////////////////////////////

   135 // (detail) metafunction find_fallback_type

   136 //

   137 // Provides a fallback (i.e., nothrow default-constructible) type from the

   138 // specified sequence, or no_fallback_type if not found.

   139 //

   140 // This implementation is designed to prefer boost::blank over other potential

   141 // fallback types, regardless of its position in the specified sequence.

   142 //

   143 

   144 class no_fallback_type;

   145 

   146 struct find_fallback_type_pred

   147 {

   148     template <typename Iterator>

   149     struct apply

   150     {

   151     private:

   152         typedef typename mpl::deref<Iterator>::type t_;

   153 

   154     public:

   155         typedef mpl::not_< has_nothrow_constructor<t_> > type;

   156     };

   157 };

   158 

   159 template <typename Types>

   160 struct find_fallback_type

   161 {

   162 private: // helpers, for metafunction result (below)

   163 

   164     typedef typename mpl::end<Types>::type end_it;

   165 

   166     // [Find the first suitable fallback type...]

   167 

   168     typedef typename mpl::iter_fold_if<

   169           Types

   170         , mpl::int_<0>, mpl::protect< mpl::next<> >

   171         , mpl::protect< find_fallback_type_pred >

   172         >::type first_result_;

   173 

   174     typedef typename first_result_::first first_result_index;

   175     typedef typename first_result_::second first_result_it;

   176 

   177     // [...now search the rest of the sequence for boost::blank...]

   178 

   179     typedef typename mpl::iter_fold_if<

   180           mpl::iterator_range< first_result_it,end_it >

   181         , first_result_index, mpl::protect< mpl::next<> >

   182         , mpl::protect< mpl::not_same_as<boost::blank> >

   183         >::type second_result_;

   184 

   185     typedef typename second_result_::second second_result_it;

   186 

   187 public: // metafunction result

   188 

   189     // [...and return the results of the search:]

   190     typedef typename mpl::eval_if<

   191           is_same< second_result_it,end_it >

   192         , mpl::if_<

   193               is_same< first_result_it,end_it >

   194             , mpl::pair< no_fallback_type,no_fallback_type >

   195             , first_result_

   196             >

   197         , mpl::identity< second_result_ >

   198         >::type type;

   199 

   200 };

   201 

   202 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)

   203 

   204 template<>

   205 struct find_fallback_type<int>

   206 {

   207     typedef mpl::pair< no_fallback_type,no_fallback_type > type;

   208 };

   209 

   210 #endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround

   211 

   212 ///////////////////////////////////////////////////////////////////////////////

   213 // (detail) metafunction make_storage

   214 //

   215 // Provides an aligned storage type capable of holding any of the types

   216 // specified in the given type-sequence.

   217 //

   218 

   219 template <typename Types, typename NeverUsesBackupFlag>

   220 struct make_storage

   221 {

   222 private: // helpers, for metafunction result (below)

   223 

   224     typedef typename mpl::eval_if<

   225           NeverUsesBackupFlag

   226         , mpl::identity< Types >

   227         , mpl::push_front<

   228               Types, backup_holder<void*>

   229             >

   230         >::type types;

   231 

   232     typedef typename max_value<

   233           types, mpl::sizeof_<mpl::_1>

   234         >::type max_size;

   235 

   236 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))

   237 

   238     typedef typename max_value<

   239           types, alignment_of<mpl::_1>

   240         >::type max_alignment;

   241 

   242 #else // borland

   243 

   244     // temporary workaround -- use maximal alignment

   245     typedef mpl::size_t< -1 > max_alignment;

   246 

   247 #endif // borland workaround

   248 

   249 public: // metafunction result

   250 

   251 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

   252 

   253     typedef ::boost::aligned_storage<

   254           BOOST_MPL_AUX_VALUE_WKND(max_size)::value

   255         , BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value

   256         > type;

   257 

   258 #else // MSVC7 and below

   259 

   260     BOOST_STATIC_CONSTANT(std::size_t, msvc_max_size_c = max_size::value);

   261     BOOST_STATIC_CONSTANT(std::size_t, msvc_max_alignment_c = max_alignment::value);

   262 

   263     typedef ::boost::aligned_storage<

   264           msvc_max_size_c

   265         , msvc_max_alignment_c

   266         > type;

   267 

   268 #endif // MSVC workaround

   269 

   270 };

   271 

   272 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)

   273 

   274 template<>

   275 struct make_storage<int,int>

   276 {

   277     typedef int type;

   278 };

   279 

   280 #endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround

   281 

   282 ///////////////////////////////////////////////////////////////////////////////

   283 // (detail) class destroyer

   284 //

   285 // Internal visitor that destroys the value it visits.

   286 //

   287 struct destroyer

   288     : public static_visitor<>

   289 {

   290 public: // visitor interfaces

   291 

   292     template <typename T>

   293         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   294     internal_visit(T& operand, int) const

   295     {

   296         operand.~T();

   297 

   298 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))

   299         operand; // suppresses warnings

   300 #endif

   301 

   302         BOOST_VARIANT_AUX_RETURN_VOID;

   303     }

   304 

   305 };

   306 

   307 ///////////////////////////////////////////////////////////////////////////////

   308 // (detail) class template known_get

   309 //

   310 // Visitor that returns a reference to content of the specified type.

   311 //

   312 // Precondition: visited variant MUST contain logical content of type T.

   313 //

   314 template <typename T>

   315 class known_get

   316     : public static_visitor<T&>

   317 {

   318 

   319 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

   320 

   321 public: // visitor interface

   322 

   323     T& operator()(T& operand) const

   324     {

   325         return operand;

   326     }

   327 

   328     template <typename U>

   329     T& operator()(U&) const

   330     {

   331         // logical error to be here: see precondition above

   332         BOOST_ASSERT(false);

   333         return ::boost::detail::variant::forced_return< T& >();

   334     }

   335 

   336 #else // MSVC6

   337 

   338 private: // helpers, for visitor interface (below)

   339 

   340     T& execute(T& operand, mpl::true_) const

   341     {

   342         return operand;

   343     }

   344 

   345     template <typename U>

   346     T& execute(U& operand, mpl::false_) const

   347     {

   348         // logical error to be here: see precondition above

   349         BOOST_ASSERT(false);

   350         return ::boost::detail::variant::forced_return< T& >();

   351     }

   352 

   353 public: // visitor interface

   354 

   355     template <typename U>

   356     T& operator()(U& operand) const

   357     {

   358         typedef typename is_same< U,T >::type

   359             U_is_T;

   360 

   361         return execute(operand, U_is_T());

   362     }

   363 

   364 #endif // MSVC6 workaround

   365 

   366 };

   367 

   368 ///////////////////////////////////////////////////////////////////////////////

   369 // (detail) class copy_into

   370 //

   371 // Internal visitor that copies the value it visits into the given buffer.

   372 //

   373 class copy_into

   374     : public static_visitor<>

   375 {

   376 private: // representation

   377 

   378     void* storage_;

   379 

   380 public: // structors

   381 

   382     explicit copy_into(void* storage)

   383         : storage_(storage)

   384     {

   385     }

   386 

   387 public: // internal visitor interface

   388 

   389     template <typename T>

   390         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   391     internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const

   392     {

   393         new(storage_) T( operand.get() );

   394         BOOST_VARIANT_AUX_RETURN_VOID;

   395     }

   396 

   397     template <typename T>

   398         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   399     internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const

   400     {

   401         new(storage_) T( operand.get() );

   402         BOOST_VARIANT_AUX_RETURN_VOID;

   403     }

   404 

   405     template <typename T>

   406         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   407     internal_visit(const T& operand, int) const

   408     {

   409         new(storage_) T(operand);

   410         BOOST_VARIANT_AUX_RETURN_VOID;

   411     }

   412 

   413 };

   414 

   415 ///////////////////////////////////////////////////////////////////////////////

   416 // (detail) class assign_storage

   417 //

   418 // Internal visitor that assigns the given storage (which must be a

   419 // constructed value of the same type) to the value it visits.

   420 //

   421 struct assign_storage

   422     : public static_visitor<>

   423 {

   424 private: // representation

   425 

   426     const void* rhs_storage_;

   427 

   428 public: // structors

   429 

   430     explicit assign_storage(const void* rhs_storage)

   431         : rhs_storage_(rhs_storage)

   432     {

   433     }

   434 

   435 public: // internal visitor interfaces

   436 

   437     template <typename T>

   438         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   439     internal_visit(backup_holder<T>& lhs_content, long) const

   440     {

   441         lhs_content.get()

   442             = static_cast< const backup_holder<T>* >(rhs_storage_)->get();

   443         BOOST_VARIANT_AUX_RETURN_VOID;

   444     }

   445 

   446     template <typename T>

   447         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   448     internal_visit(const backup_holder<T>& lhs_content, long) const

   449     {

   450         lhs_content.get()

   451             = static_cast< const backup_holder<T>* >(rhs_storage_)->get();

   452         BOOST_VARIANT_AUX_RETURN_VOID;

   453     }

   454 

   455     template <typename T>

   456         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   457     internal_visit(T& lhs_content, int) const

   458     {

   459         // NOTE TO USER :

   460         // Compile error here indicates one of variant's bounded types does

   461         // not meet the requirements of the Assignable concept. Thus,

   462         // variant is not Assignable.

   463         //

   464         // Hint: Are any of the bounded types const-qualified or references?

   465         //

   466         lhs_content = *static_cast< const T* >(rhs_storage_);

   467         BOOST_VARIANT_AUX_RETURN_VOID;

   468     }

   469 

   470 };

   471 

   472 ///////////////////////////////////////////////////////////////////////////////

   473 // (detail) class direct_assigner

   474 //

   475 // Generic static visitor that: if and only if the visited value is of the

   476 // specified type, assigns the given value to the visited value and returns

   477 // true; else returns false.

   478 //

   479 template <typename T>

   480 class direct_assigner

   481     : public static_visitor<bool>

   482 {

   483 private: // representation

   484 

   485     T& rhs_;

   486 

   487 public: // structors

   488 

   489     explicit direct_assigner(T& rhs)

   490         : rhs_(rhs)

   491     {

   492     }

   493 

   494 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

   495 

   496 public: // visitor interface

   497 

   498     bool operator()(T& lhs)

   499     {

   500         lhs = rhs_;

   501         return true;

   502     }

   503 

   504     template <typename U>

   505     bool operator()(U&)

   506     {

   507         return false;

   508     }

   509 

   510 #else // MSVC6

   511 

   512 private: // helpers, for visitor interface (below)

   513 

   514     bool execute(T& lhs, mpl::true_)

   515     {

   516         lhs = rhs_;

   517         return true;

   518     }

   519 

   520     template <typename U>

   521     bool execute(U&, mpl::false_)

   522     {

   523         return false;

   524     }

   525 

   526 public: // visitor interface

   527 

   528     template <typename U>

   529     bool operator()(U& lhs)

   530     {

   531         typedef typename is_same<U,T>::type U_is_T;

   532         return execute(lhs, U_is_T());

   533     }

   534 

   535 #endif // MSVC6 workaround

   536 

   537 };

   538 

   539 ///////////////////////////////////////////////////////////////////////////////

   540 // (detail) class backup_assigner

   541 //

   542 // Internal visitor that "assigns" the given value to the visited value,

   543 // using backup to recover if the destroy-copy sequence fails.

   544 //

   545 // NOTE: This needs to be a friend of variant, as it needs access to

   546 // indicate_which, indicate_backup_which, etc.

   547 //

   548 template <typename Variant, typename RhsT>

   549 class backup_assigner

   550     : public static_visitor<>

   551 {

   552 private: // representation

   553 

   554     Variant& lhs_;

   555     int rhs_which_;

   556     const RhsT& rhs_content_;

   557 

   558 public: // structors

   559 

   560     backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)

   561         : lhs_(lhs)

   562         , rhs_which_(rhs_which)

   563         , rhs_content_(rhs_content)

   564     {

   565     }

   566 

   567 private: // helpers, for visitor interface (below)

   568 

   569     template <typename LhsT>

   570     void backup_assign_impl(

   571           LhsT& lhs_content

   572         , mpl::true_// has_nothrow_move

   573         )

   574     {

   575         // Move lhs content to backup...

   576         LhsT backup_lhs_content(

   577               ::boost::detail::variant::move(lhs_content)

   578             ); // nothrow

   579 

   580         // ...destroy lhs content...

   581         lhs_content.~LhsT(); // nothrow

   582 

   583         try

   584         {

   585             // ...and attempt to copy rhs content into lhs storage:

   586             new(lhs_.storage_.address()) RhsT(rhs_content_);

   587         }

   588         catch (...)

   589         {

   590             // In case of failure, restore backup content to lhs storage...

   591             new(lhs_.storage_.address())

   592                 LhsT(

   593                       ::boost::detail::variant::move(backup_lhs_content)

   594                     ); // nothrow

   595 

   596             // ...and rethrow:

   597             throw;

   598         }

   599 

   600         // In case of success, indicate new content type:

   601         lhs_.indicate_which(rhs_which_); // nothrow

   602     }

   603 

   604     template <typename LhsT>

   605     void backup_assign_impl(

   606           LhsT& lhs_content

   607         , mpl::false_// has_nothrow_move

   608         )

   609     {

   610         // Backup lhs content...

   611         LhsT* backup_lhs_ptr = new LhsT(lhs_content);

   612 

   613         // ...destroy lhs content...

   614         lhs_content.~LhsT(); // nothrow

   615 

   616         try

   617         {

   618             // ...and attempt to copy rhs content into lhs storage:

   619             new(lhs_.storage_.address()) RhsT(rhs_content_);

   620         }

   621         catch (...)

   622         {

   623             // In case of failure, copy backup pointer to lhs storage...

   624             new(lhs_.storage_.address())

   625                 backup_holder<LhsT>( backup_lhs_ptr ); // nothrow

   626 

   627             // ...indicate now using backup...

   628             lhs_.indicate_backup_which( lhs_.which() ); // nothrow

   629 

   630             // ...and rethrow:

   631             throw;

   632         }

   633 

   634         // In case of success, indicate new content type...

   635         lhs_.indicate_which(rhs_which_); // nothrow

   636 

   637         // ...and delete backup:

   638         delete backup_lhs_ptr; // nothrow

   639     }

   640 

   641 public: // visitor interface

   642 

   643     template <typename LhsT>

   644         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   645     internal_visit(LhsT& lhs_content, int)

   646     {

   647         typedef typename has_nothrow_move_constructor<LhsT>::type

   648             nothrow_move;

   649 

   650         backup_assign_impl( lhs_content, nothrow_move() );

   651 

   652         BOOST_VARIANT_AUX_RETURN_VOID;

   653     }

   654 

   655 };

   656 

   657 ///////////////////////////////////////////////////////////////////////////////

   658 // (detail) class swap_with

   659 //

   660 // Visitor that swaps visited value with content of given variant.

   661 //

   662 // Precondition: Given variant MUST have same logical type as visited value.

   663 //

   664 template <typename Variant>

   665 struct swap_with

   666     : public static_visitor<>

   667 {

   668 private: // representation

   669 

   670     Variant& toswap_;

   671 

   672 public: // structors

   673 

   674     explicit swap_with(Variant& toswap)

   675         : toswap_(toswap)

   676     {

   677     }

   678 

   679 public: // internal visitor interfaces

   680 

   681     template <typename T>

   682     void operator()(T& operand) const

   683     {

   684         // Since the precondition ensures types are same, get T...

   685         known_get<T> getter;

   686         T& other = toswap_.apply_visitor(getter);

   687 

   688         // ...and swap:

   689         ::boost::detail::variant::move_swap( operand, other );

   690     }

   691 

   692 };

   693 

   694 ///////////////////////////////////////////////////////////////////////////////

   695 // (detail) class reflect

   696 //

   697 // Generic static visitor that performs a typeid on the value it visits.

   698 //

   699 class reflect

   700     : public static_visitor<const std::type_info&>

   701 {

   702 public: // visitor interfaces

   703 

   704     template <typename T>

   705     const std::type_info& operator()(const T&) const

   706     {

   707         return typeid(T);

   708     }

   709 

   710 };

   711 

   712 ///////////////////////////////////////////////////////////////////////////////

   713 // (detail) class comparer

   714 //

   715 // Generic static visitor that compares the content of the given lhs variant

   716 // with the visited rhs content using Comp.

   717 //

   718 // Precondition: lhs.which() == rhs.which()

   719 //

   720 template <typename Variant, typename Comp>

   721 class comparer

   722     : public static_visitor<bool>

   723 {

   724 private: // representation

   725 

   726     const Variant& lhs_;

   727 

   728 public: // structors

   729 

   730     explicit comparer(const Variant& lhs)

   731         : lhs_(lhs)

   732     {

   733     }

   734 

   735 public: // visitor interfaces

   736 

   737     template <typename T>

   738     bool operator()(const T& rhs_content) const

   739     {

   740         // Since the precondition ensures lhs and rhs types are same, get T...

   741         known_get<const T> getter;

   742         const T& lhs_content = lhs_.apply_visitor(getter);

   743 

   744         // ...and compare lhs and rhs contents:

   745         return Comp()(lhs_content, rhs_content);

   746     }

   747 

   748 };

   749 

   750 ///////////////////////////////////////////////////////////////////////////////

   751 // (detail) class equal_comp

   752 //

   753 // Generic function object compares lhs with rhs using operator==.

   754 //

   755 struct equal_comp

   756 {

   757     template <typename T>

   758     bool operator()(const T& lhs, const T& rhs) const

   759     {

   760         return lhs == rhs;

   761     }

   762 };

   763 

   764 ///////////////////////////////////////////////////////////////////////////////

   765 // (detail) class less_comp

   766 //

   767 // Generic function object compares lhs with rhs using operator<.

   768 //

   769 struct less_comp

   770 {

   771     template <typename T>

   772     bool operator()(const T& lhs, const T& rhs) const

   773     {

   774         return lhs < rhs;

   775     }

   776 };

   777 

   778 ///////////////////////////////////////////////////////////////////////////////

   779 // (detail) class template invoke_visitor

   780 //

   781 // Internal visitor that invokes the given visitor using:

   782 //  * for wrappers (e.g., recursive_wrapper), the wrapper's held value.

   783 //  * for all other values, the value itself.

   784 //

   785 template <typename Visitor>

   786 class invoke_visitor

   787 {

   788 private: // representation

   789 

   790     Visitor& visitor_;

   791 

   792 public: // visitor typedefs

   793 

   794     typedef typename Visitor::result_type

   795         result_type;

   796 

   797 public: // structors

   798 

   799     explicit invoke_visitor(Visitor& visitor)

   800         : visitor_(visitor)

   801     {

   802     }

   803 

   804 #if !defined(BOOST_NO_VOID_RETURNS)

   805 

   806 public: // internal visitor interfaces

   807 

   808     template <typename T>

   809     result_type internal_visit(T& operand, int)

   810     {

   811         return visitor_(operand);

   812     }

   813 

   814 #   if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))

   815     template <typename T>

   816     result_type internal_visit(const T& operand, int)

   817     {

   818         return visitor_(operand);

   819     }

   820 #   endif

   821 

   822 #else // defined(BOOST_NO_VOID_RETURNS)

   823 

   824 private: // helpers, for internal visitor interfaces (below)

   825 

   826     template <typename T>

   827         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   828     visit_impl(T& operand, mpl::false_)

   829     {

   830         return visitor_(operand);

   831     }

   832 

   833     template <typename T>

   834         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

   835     visit_impl(T& operand, mpl::true_)

   836     {

   837         visitor_(operand);

   838         BOOST_VARIANT_AUX_RETURN_VOID;

   839     }

   840 

   841 public: // internal visitor interfaces

   842 

   843     template <typename T>

   844         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   845     internal_visit(T& operand, int)

   846     {

   847         typedef typename is_same<result_type, void>::type

   848             has_void_result_type;

   849 

   850         return visit_impl(operand, has_void_result_type());

   851     }

   852 

   853 #endif // BOOST_NO_VOID_RETURNS) workaround

   854 

   855 public: // internal visitor interfaces, cont.

   856 

   857     template <typename T>

   858         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   859     internal_visit(boost::recursive_wrapper<T>& operand, long)

   860     {

   861         return internal_visit( operand.get(), 1L );

   862     }

   863 

   864     template <typename T>

   865         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   866     internal_visit(const boost::recursive_wrapper<T>& operand, long)

   867     {

   868         return internal_visit( operand.get(), 1L );

   869     }

   870 

   871     template <typename T>

   872         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   873     internal_visit(boost::detail::reference_content<T>& operand, long)

   874     {

   875         return internal_visit( operand.get(), 1L );

   876     }

   877 

   878     template <typename T>

   879         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   880     internal_visit(const boost::detail::reference_content<T>& operand, long)

   881     {

   882         return internal_visit( operand.get(), 1L );

   883     }

   884 

   885     template <typename T>

   886         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   887     internal_visit(boost::detail::variant::backup_holder<T>& operand, long)

   888     {

   889         return internal_visit( operand.get(), 1L );

   890     }

   891 

   892     template <typename T>

   893         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

   894     internal_visit(const boost::detail::variant::backup_holder<T>& operand, long)

   895     {

   896         return internal_visit( operand.get(), 1L );

   897     }

   898 

   899 };

   900 

   901 }} // namespace detail::variant

   902 

   903 ///////////////////////////////////////////////////////////////////////////////

   904 // class template variant (concept inspired by Andrei Alexandrescu)

   905 //

   906 // See docs and boost/variant/variant_fwd.hpp for more information.

   907 //

   908 template <

   909       typename T0_

   910     , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)

   911     >

   912 class variant

   913 {

   914 private: // helpers, for typedefs (below)

   915 

   916     typedef variant wknd_self_t;

   917 

   918     struct is_recursive_

   919         : detail::variant::is_recursive_flag<T0_>

   920     {

   921     };

   922 

   923     typedef typename mpl::eval_if<

   924           is_recursive_

   925         , T0_

   926         , mpl::identity< T0_ >

   927         >::type unwrapped_T0_;

   928 

   929     struct is_sequence_based_

   930         : detail::variant::is_over_sequence<unwrapped_T0_>

   931     {

   932     };

   933 

   934 #if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)

   935 

   936 private: // helpers, for typedefs (below)

   937 

   938     typedef typename mpl::eval_if<

   939           is_sequence_based_

   940         , unwrapped_T0_ // over_sequence<...>::type

   941         , detail::variant::make_variant_list<

   942               unwrapped_T0_

   943             , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)

   944             >

   945         >::type specified_types;

   946 

   947     BOOST_STATIC_ASSERT((

   948           ::boost::mpl::not_< mpl::empty<specified_types> >::value

   949         ));

   950 

   951     typedef typename mpl::eval_if<

   952           is_recursive_

   953         , mpl::transform<

   954               specified_types

   955             , mpl::protect<

   956                   detail::variant::quoted_enable_recursive<wknd_self_t>

   957                 >

   958             >

   959         , mpl::identity< specified_types >

   960         >::type recursive_enabled_types;

   961 

   962 public: // public typedefs

   963 

   964     typedef typename mpl::transform<

   965           recursive_enabled_types

   966         , unwrap_recursive<mpl::_1>

   967         >::type types;

   968 

   969 private: // internal typedefs

   970 

   971     typedef typename mpl::transform<

   972           recursive_enabled_types

   973         , mpl::protect< detail::make_reference_content<> >

   974         >::type internal_types;

   975 

   976     typedef typename mpl::front<

   977           internal_types

   978         >::type internal_T0;

   979 

   980 #else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)

   981 

   982 private: // helpers, for typedefs (below)

   983 

   984     typedef unwrapped_T0_ T0;

   985 

   986     #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \

   987         typedef typename mpl::eval_if< \

   988               is_recursive_ \

   989             , detail::variant::enable_recursive< \

   990                   BOOST_PP_CAT(T,N) \

   991                 , wknd_self_t \

   992                 > \

   993             , mpl::identity< BOOST_PP_CAT(T,N) > \

   994             >::type BOOST_PP_CAT(recursive_enabled_T,N); \

   995         /**/

   996 

   997     BOOST_PP_REPEAT(

   998           BOOST_VARIANT_LIMIT_TYPES

   999         , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS

  1000         , _

  1001         )

  1002 

  1003     #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS

  1004 

  1005     #define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \

  1006         typedef typename unwrap_recursive< \

  1007               BOOST_PP_CAT(recursive_enabled_T,N) \

  1008             >::type BOOST_PP_CAT(public_T,N); \

  1009         /**/

  1010 

  1011     BOOST_PP_REPEAT(

  1012           BOOST_VARIANT_LIMIT_TYPES

  1013         , BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS

  1014         , _

  1015         )

  1016 

  1017     #undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS

  1018 

  1019 public: // public typedefs

  1020 

  1021     typedef typename detail::variant::make_variant_list<

  1022           BOOST_VARIANT_ENUM_PARAMS(public_T)

  1023         >::type types;

  1024 

  1025 private: // helpers, for internal typedefs (below)

  1026 

  1027     #define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \

  1028         typedef detail::make_reference_content< \

  1029               BOOST_PP_CAT(recursive_enabled_T,N) \

  1030             >::type BOOST_PP_CAT(internal_T,N); \

  1031         /**/

  1032 

  1033     BOOST_PP_REPEAT(

  1034           BOOST_VARIANT_LIMIT_TYPES

  1035         , BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS

  1036         , _

  1037         )

  1038 

  1039     #undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS

  1040 

  1041 private: // internal typedefs

  1042 

  1043     typedef typename detail::variant::make_variant_list<

  1044           BOOST_VARIANT_ENUM_PARAMS(internal_T)

  1045         >::type internal_types;

  1046 

  1047 private: // static precondition assertions

  1048 

  1049     // NOTE TO USER :

  1050     // variant< type-sequence > syntax is not supported on this compiler!

  1051     //

  1052     BOOST_MPL_ASSERT_NOT(( is_sequence_based_ ));

  1053 

  1054 #endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround

  1055 

  1056 private: // helpers, for representation (below)

  1057 

  1058     typedef typename detail::variant::find_fallback_type<

  1059           internal_types

  1060         >::type fallback_type_result_;

  1061 

  1062     typedef typename fallback_type_result_::first

  1063         fallback_type_index_;

  1064     typedef typename fallback_type_result_::second

  1065         fallback_type_;

  1066 

  1067     struct has_fallback_type_

  1068         : mpl::not_<

  1069               is_same< fallback_type_, detail::variant::no_fallback_type >

  1070             >

  1071     {

  1072     };

  1073 

  1074     typedef has_fallback_type_

  1075         never_uses_backup_flag;

  1076 

  1077     typedef typename detail::variant::make_storage<

  1078           internal_types, never_uses_backup_flag

  1079         >::type storage_t;

  1080 

  1081 private: // helpers, for representation (below)

  1082 

  1083     // which_ on:

  1084     // * [0,  size<internal_types>) indicates stack content

  1085     // * [-size<internal_types>, 0) indicates pointer to heap backup

  1086     // if which_ >= 0:

  1087     // * then which() -> which_

  1088     // * else which() -> -(which_ + 1)

  1089 

  1090 #if !defined(BOOST_VARIANT_MINIMIZE_SIZE)

  1091 

  1092     typedef int which_t;

  1093 

  1094 #else // defined(BOOST_VARIANT_MINIMIZE_SIZE)

  1095 

  1096     // [if O1_size available, then attempt which_t size optimization...]

  1097     // [select signed char if fewer than SCHAR_MAX types, else signed int:]

  1098     typedef typename mpl::eval_if<

  1099           mpl::equal_to< mpl::O1_size<internal_types>, mpl::long_<-1> >

  1100         , mpl::identity< int >

  1101         , mpl::if_<

  1102               mpl::less< mpl::O1_size<internal_types>, mpl::int_<SCHAR_MAX> >

  1103             , signed char

  1104             , int

  1105             >

  1106         >::type which_t;

  1107 

  1108 #endif // BOOST_VARIANT_MINIMIZE_SIZE switch

  1109 

  1110 // representation -- private when possible

  1111 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)

  1112     private:

  1113 #else

  1114     public:

  1115 #endif

  1116 

  1117     which_t which_;

  1118     storage_t storage_;

  1119 

  1120     void indicate_which(int which)

  1121     {

  1122         which_ = static_cast<which_t>( which );

  1123     }

  1124 

  1125     void indicate_backup_which(int which)

  1126     {

  1127         which_ = static_cast<which_t>( -(which + 1) );

  1128     }

  1129 

  1130 private: // helpers, for queries (below)

  1131 

  1132     bool using_backup() const

  1133     {

  1134         return which_ < 0;