Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/foreach.hpp@260cb5ec6c19

     1 ///////////////////////////////////////////////////////////////////////////////

     2 // foreach.hpp header file

     3 //

     4 // Copyright 2004 Eric Niebler.

     5 // Distributed under the Boost Software License, Version 1.0. (See

     6 // accompanying file LICENSE_1_0.txt or copy at

     7 // http://www.boost.org/LICENSE_1_0.txt)

     8 //

     9 // Credits:

    10 //  Anson Tsao        - for the initial inspiration and several good suggestions.

    11 //  Thorsten Ottosen  - for Boost.Range, and for suggesting a way to detect

    12 //                      const-qualified rvalues at compile time on VC7.1+

    13 //  Russell Hind      - For help porting to Borland

    14 //  Alisdair Meredith - For help porting to Borland

    15 //  Stefan Slapeta    - For help porting to Intel

    17 #ifndef BOOST_FOREACH

    19 // MS compatible compilers support #pragma once

    20 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

    21 # pragma once

    22 #endif

    24 #include <cstddef>

    25 #include <utility>  // for std::pair

    27 #include <boost/config.hpp>

    28 #include <boost/detail/workaround.hpp>

    30 // Some compilers let us detect even const-qualified rvalues at compile-time

    31 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)                                                       \

    32  || (BOOST_WORKAROUND(__GNUC__, >= 4) && !defined(BOOST_INTEL))                                 \

    33  || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL))

    34 # define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION

    35 #else

    36 // Some compilers allow temporaries to be bound to non-const references.

    37 // These compilers make it impossible to for BOOST_FOREACH to detect

    38 // temporaries and avoid reevaluation of the collection expression.

    39 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                                      \

    40   || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))                                     \

    41   || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))                   \

    42   || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))                                      \

    43   || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))

    44 #  define BOOST_FOREACH_NO_RVALUE_DETECTION

    45 # endif

    46 // Some compilers do not correctly implement the lvalue/rvalue conversion

    47 // rules of the ternary conditional operator.

    48 # if defined(BOOST_FOREACH_NO_RVALUE_DETECTION)                                                 \

    49   || defined(BOOST_NO_SFINAE)                                                                   \

    50   || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))                                        \

    51   || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 810)                                                  \

    52   || BOOST_WORKAROUND(__GNUC__, < 3)                                                            \

    53   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2))                                \

    54   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__))       \

    55   || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))                                         \

    56   || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))

    57 #  define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION

    58 # else

    59 #  define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION

    60 # endif

    61 #endif

    63 #include <boost/mpl/if.hpp>

    64 #include <boost/mpl/logical.hpp>

    65 #include <boost/mpl/eval_if.hpp>

    66 #include <boost/noncopyable.hpp>

    67 #include <boost/range/end.hpp>

    68 #include <boost/range/begin.hpp>

    69 #include <boost/range/result_iterator.hpp>

    70 #include <boost/type_traits/is_array.hpp>

    71 #include <boost/type_traits/is_const.hpp>

    72 #include <boost/type_traits/is_abstract.hpp>

    73 #include <boost/type_traits/is_base_and_derived.hpp>

    74 #include <boost/iterator/iterator_traits.hpp>

    75 #include <boost/utility/addressof.hpp>

    77 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION

    78 # include <new>

    79 # include <boost/aligned_storage.hpp>

    80 # include <boost/utility/enable_if.hpp>

    81 # include <boost/type_traits/remove_const.hpp>

    82 #endif

    84 // This must be at global scope, hence the uglified name

    85 enum boost_foreach_argument_dependent_lookup_hack

    86 {

    87     boost_foreach_argument_dependent_lookup_hack_value

    88 };

    90 namespace boost

    91 {

    93 // forward declarations for iterator_range

    94 template<typename T>

    95 class iterator_range;

    97 // forward declarations for sub_range

    98 template<typename T>

    99 class sub_range;

   101 namespace foreach

   102 {

   103     ///////////////////////////////////////////////////////////////////////////////

   104     // in_range

   105     //

   106     template<typename T>

   107     inline std::pair<T, T> in_range(T begin, T end)

   108     {

   109         return std::make_pair(begin, end);

   110     }

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

   113     // boost::foreach::tag

   114     //

   115     typedef boost_foreach_argument_dependent_lookup_hack tag;

   117     ///////////////////////////////////////////////////////////////////////////////

   118     // boost::foreach::is_lightweight_proxy

   119     //   Specialize this for user-defined collection types if they are inexpensive to copy.

   120     //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.

   121     template<typename T>

   122     struct is_lightweight_proxy

   123       : boost::mpl::false_

   124     {

   125     };

   127     ///////////////////////////////////////////////////////////////////////////////

   128     // boost::foreach::is_noncopyable

   129     //   Specialize this for user-defined collection types if they cannot be copied.

   130     //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.

   131     template<typename T>

   132     struct is_noncopyable

   133     #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT)

   134       : boost::mpl::or_<

   135             boost::is_abstract<T>

   136           , boost::is_base_and_derived<boost::noncopyable, T>

   137         >

   138     #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED)

   139       : boost::is_base_and_derived<boost::noncopyable, T>

   140     #elif !defined(BOOST_NO_IS_ABSTRACT)

   141       : boost::is_abstract<T>

   142     #else

   143       : boost::mpl::false_

   144     #endif

   145     {

   146     };

   148 } // namespace foreach

   150 } // namespace boost

   152 // vc6/7 needs help ordering the following overloads

   153 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   154 # define BOOST_FOREACH_TAG_DEFAULT ...

   155 #else

   156 # define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag

   157 #endif

   159 ///////////////////////////////////////////////////////////////////////////////

   160 // boost_foreach_is_lightweight_proxy

   161 //   Another customization point for the is_lightweight_proxy optimization,

   162 //   this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy

   163 //   at the global namespace for your type.

   164 template<typename T>

   165 inline boost::foreach::is_lightweight_proxy<T> *

   166 boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }

   168 template<typename T>

   169 inline boost::mpl::true_ *

   170 boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; }

   172 template<typename T>

   173 inline boost::mpl::true_ *

   174 boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; }

   176 template<typename T>

   177 inline boost::mpl::true_ *

   178 boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; }

   180 template<typename T>

   181 inline boost::mpl::true_ *

   182 boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; }

   184 ///////////////////////////////////////////////////////////////////////////////

   185 // boost_foreach_is_noncopyable

   186 //   Another customization point for the is_noncopyable trait,

   187 //   this one works on legacy compilers. Overload boost_foreach_is_noncopyable

   188 //   at the global namespace for your type.

   189 template<typename T>

   190 inline boost::foreach::is_noncopyable<T> *

   191 boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }

   193 namespace boost

   194 {

   196 namespace foreach_detail_

   197 {

   199 ///////////////////////////////////////////////////////////////////////////////

   200 // Define some utilities for assessing the properties of expressions

   201 //

   202 typedef char yes_type;

   203 typedef char (&no_type)[2];

   204 yes_type is_true(boost::mpl::true_ *);

   205 no_type is_true(boost::mpl::false_ *);

   207 // Extracts the desired property from the expression without evaluating it

   208 #define BOOST_FOREACH_PROTECT(expr)                                                             \

   209     (static_cast<boost::mpl::bool_<1 == sizeof(boost::foreach_detail_::is_true(expr))> *>(0))

   211 template<typename Bool1, typename Bool2>

   212 inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }

   214 template<typename Bool1, typename Bool2, typename Bool3>

   215 inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }

   217 template<typename Bool1, typename Bool2>

   218 inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }

   220 template<typename Bool1, typename Bool2, typename Bool3>

   221 inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }

   223 template<typename Bool>

   224 inline boost::mpl::not_<Bool> *not_(Bool *) { return 0; }

   226 template<typename T>

   227 inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }

   229 template<typename T>

   230 inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }

   232 template<typename T>

   233 inline boost::is_array<T> *is_array_(T const &) { return 0; }

   235 template<typename T>

   236 inline boost::is_const<T> *is_const_(T &) { return 0; }

   238 #ifndef BOOST_FOREACH_NO_RVALUE_DETECTION

   239 template<typename T>

   240 inline boost::mpl::true_ *is_const_(T const &) { return 0; }

   241 #endif

   243 ///////////////////////////////////////////////////////////////////////////////

   244 // auto_any_t/auto_any

   245 //  General utility for putting an object of any type into automatic storage

   246 struct auto_any_base

   247 {

   248     // auto_any_base must evaluate to false in boolean context so that

   249     // they can be declared in if() statements.

   250     operator bool() const

   251     {

   252         return false;

   253     }

   254 };

   256 template<typename T>

   257 struct auto_any : auto_any_base

   258 {

   259     auto_any(T const &t)

   260       : item(t)

   261     {

   262     }

   264     // temporaries of type auto_any will be bound to const auto_any_base

   265     // references, but we still want to be able to mutate the stored

   266     // data, so declare it as mutable.

   267     mutable T item;

   268 };

   270 typedef auto_any_base const &auto_any_t;

   272 template<typename T, typename C>

   273 inline BOOST_DEDUCED_TYPENAME boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)

   274 {

   275     return static_cast<auto_any<T> const &>(a).item;

   276 }

   278 typedef boost::mpl::true_ const_;

   280 ///////////////////////////////////////////////////////////////////////////////

   281 // type2type

   282 //

   283 template<typename T, typename C = boost::mpl::false_>

   284 struct type2type

   285   : boost::mpl::if_<C, T const, T>

   286 {

   287 };

   289 template<typename T, typename C = boost::mpl::false_>

   290 struct foreach_iterator

   291 {

   292     typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<

   293         C

   294       , range_const_iterator<T>

   295       , range_iterator<T>

   296     >::type type;

   297 };

   299 template<typename T, typename C = boost::mpl::false_>

   300 struct foreach_reference

   301   : iterator_reference<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>

   302 {

   303 };

   305 ///////////////////////////////////////////////////////////////////////////////

   306 // encode_type

   307 //

   308 template<typename T>

   309 inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }

   311 template<typename T>

   312 inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }

   314 ///////////////////////////////////////////////////////////////////////////////

   315 // set_false

   316 //

   317 inline bool set_false(bool &b) { return b = false; }

   319 ///////////////////////////////////////////////////////////////////////////////

   320 // to_ptr

   321 //

   322 template<typename T>

   323 inline T *&to_ptr(T const &)

   324 {

   325     static T *t = 0;

   326     return t;

   327 }

   329 // Borland needs a little extra help with arrays

   330 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   331 template<typename T,std::size_t N>

   332 inline T (*&to_ptr(T (&)[N]))[N]

   333 {

   334     static T (*t)[N] = 0;

   335     return t;

   336 }

   337 #endif

   339 ///////////////////////////////////////////////////////////////////////////////

   340 // derefof

   341 //

   342 template<typename T>

   343 inline T &derefof(T *t)

   344 {

   345     // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N],

   346     // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue.

   347     return reinterpret_cast<T &>(

   348         *const_cast<char *>(

   349             reinterpret_cast<char const volatile *>(t)

   350         )

   351     );

   352 }

   354 #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION

   355 ///////////////////////////////////////////////////////////////////////////////

   356 // Detect at compile-time whether an expression yields an rvalue or

   357 // an lvalue. This is rather non-standard, but some popular compilers

   358 // accept it.

   359 ///////////////////////////////////////////////////////////////////////////////

   361 ///////////////////////////////////////////////////////////////////////////////

   362 // rvalue_probe

   363 //

   364 template<typename T>

   365 struct rvalue_probe

   366 {

   367     struct private_type_ {};

   368     // can't ever return an array by value

   369     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<

   370         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T

   371     >::type value_type;

   372     operator value_type();

   373     operator T &() const;

   374 };

   376 template<typename T>

   377 rvalue_probe<T> const make_probe(T const &t);

   379 # define BOOST_FOREACH_IS_RVALUE(COL)                                                           \

   380     boost::foreach_detail_::and_(                                                               \

   381         boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL))                    \

   382       , BOOST_FOREACH_PROTECT(boost::foreach_detail_::is_rvalue_(                               \

   383             (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0)))

   385 #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)

   386 ///////////////////////////////////////////////////////////////////////////////

   387 // Detect at run-time whether an expression yields an rvalue

   388 // or an lvalue. This is 100% standard C++, but not all compilers

   389 // accept it. Also, it causes FOREACH to break when used with non-

   390 // copyable collection types.

   391 ///////////////////////////////////////////////////////////////////////////////

   393 ///////////////////////////////////////////////////////////////////////////////

   394 // rvalue_probe

   395 //

   396 template<typename T>

   397 struct rvalue_probe

   398 {

   399     rvalue_probe(T &t, bool &b)

   400       : value(t)

   401       , is_rvalue(b)

   402     {

   403     }

   405     struct private_type_ {};

   406     // can't ever return an array or an abstract type by value

   407     #ifdef BOOST_NO_IS_ABSTRACT

   408     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<

   409         boost::is_array<T>, private_type_, T

   410     >::type value_type;

   411     #else

   412     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<

   413         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T

   414     >::type value_type;

   415     #endif

   417     operator value_type()

   418     {

   419         this->is_rvalue = true;

   420         return this->value;

   421     }

   423     operator T &() const

   424     {

   425         return this->value;

   426     }

   428 private:

   429     T &value;

   430     bool &is_rvalue;

   431 };

   433 template<typename T>

   434 rvalue_probe<T> make_probe(T &t, bool &b) { return rvalue_probe<T>(t, b); }

   436 template<typename T>

   437 rvalue_probe<T const> make_probe(T const &t, bool &b)  { return rvalue_probe<T const>(t, b); }

   439 ///////////////////////////////////////////////////////////////////////////////

   440 // simple_variant

   441 //  holds either a T or a T const*

   442 template<typename T>

   443 struct simple_variant

   444 {

   445     simple_variant(T const *t)

   446       : is_rvalue(false)

   447     {

   448         *static_cast<T const **>(this->data.address()) = t;

   449     }

   451     simple_variant(T const &t)

   452       : is_rvalue(true)

   453     {

   454         ::new(this->data.address()) T(t);

   455     }

   457     simple_variant(simple_variant const &that)

   458       : is_rvalue(that.is_rvalue)

   459     {

   460         if(this->is_rvalue)

   461             ::new(this->data.address()) T(*that.get());

   462         else

   463             *static_cast<T const **>(this->data.address()) = that.get();

   464     }

   466     ~simple_variant()

   467     {

   468         if(this->is_rvalue)

   469             this->get()->~T();

   470     }

   472     T const *get() const

   473     {

   474         if(this->is_rvalue)

   475             return static_cast<T const *>(this->data.address());

   476         else

   477             return *static_cast<T const * const *>(this->data.address());

   478     }

   480 private:

   481     enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) };

   482     simple_variant &operator =(simple_variant const &);

   483     bool const is_rvalue;

   484     aligned_storage<size> data;

   485 };

   487 // If the collection is an array or is noncopyable, it must be an lvalue.

   488 // If the collection is a lightweight proxy, treat it as an rvalue

   489 // BUGBUG what about a noncopyable proxy?

   490 template<typename LValue, typename IsProxy>

   491 inline BOOST_DEDUCED_TYPENAME boost::enable_if<boost::mpl::or_<LValue, IsProxy>, IsProxy>::type *

   492 should_copy_impl(LValue *, IsProxy *, bool *)

   493 {

   494     return 0;

   495 }

   497 // Otherwise, we must determine at runtime whether it's an lvalue or rvalue

   498 inline bool *

   499 should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)

   500 {

   501     return is_rvalue;

   502 }

   504 #endif

   506 ///////////////////////////////////////////////////////////////////////////////

   507 // contain

   508 //

   509 template<typename T>

   510 inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue

   511 {

   512     return t;

   513 }

   515 template<typename T>

   516 inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue

   517 {

   518     // Cannot seem to get sunpro to handle addressof() with array types.

   519     #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))

   520     return &t;

   521     #else

   522     return boost::addressof(t);

   523     #endif

   524 }

   526 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION

   527 template<typename T>

   528 auto_any<simple_variant<T> >

   529 contain(T const &t, bool *rvalue)

   530 {

   531     return *rvalue ? simple_variant<T>(t) : simple_variant<T>(&t);

   532 }

   533 #endif

   535 /////////////////////////////////////////////////////////////////////////////

   536 // begin

   537 //

   538 template<typename T, typename C>

   539 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>

   540 begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue

   541 {

   542     return boost::begin(auto_any_cast<T, C>(col));

   543 }

   545 template<typename T, typename C>

   546 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>

   547 begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue

   548 {

   549     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;

   550     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;

   551     return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));

   552 }

   554 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION

   555 template<typename T>

   556 auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>

   557 begin(auto_any_t col, type2type<T, const_> *, bool *)

   558 {

   559     return boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());

   560 }

   561 #endif

   563 ///////////////////////////////////////////////////////////////////////////////

   564 // end

   565 //

   566 template<typename T, typename C>

   567 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>

   568 end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue

   569 {

   570     return boost::end(auto_any_cast<T, C>(col));

   571 }

   573 template<typename T, typename C>

   574 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>

   575 end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue

   576 {

   577     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;

   578     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;

   579     return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));

   580 }

   582 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION

   583 template<typename T>

   584 auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>

   585 end(auto_any_t col, type2type<T, const_> *, bool *)

   586 {

   587     return boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());

   588 }

   589 #endif

   591 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   592 template<typename T, typename C>

   593 inline auto_any<int>

   594 end(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings

   595 {

   596     return 0; // not used

   597 }

   598 #endif

   600 ///////////////////////////////////////////////////////////////////////////////

   601 // done

   602 //

   603 template<typename T, typename C>

   604 inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)

   605 {

   606     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;

   607     return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);

   608 }

   610 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   611 template<typename T, typename C>

   612 inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *) // null-terminated C-style strings

   613 {

   614     return ! *auto_any_cast<T *, boost::mpl::false_>(cur);

   615 }

   616 #endif

   618 ///////////////////////////////////////////////////////////////////////////////

   619 // next

   620 //

   621 template<typename T, typename C>

   622 inline void next(auto_any_t cur, type2type<T, C> *)

   623 {

   624     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;

   625     ++auto_any_cast<iter_t, boost::mpl::false_>(cur);

   626 }

   628 ///////////////////////////////////////////////////////////////////////////////

   629 // deref

   630 //

   631 template<typename T, typename C>

   632 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type

   633 deref(auto_any_t cur, type2type<T, C> *)

   634 {

   635     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;

   636     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);

   637 }

   639 } // namespace foreach_detail_

   640 } // namespace boost

   642 // A sneaky way to get the type of the collection without evaluating the expression

   643 #define BOOST_FOREACH_TYPEOF(COL)                                                               \

   644     (true ? 0 : boost::foreach_detail_::encode_type(COL, boost::foreach_detail_::is_const_(COL)))

   646 // returns true_* if the type is noncopyable

   647 #define BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                       \

   648     boost_foreach_is_noncopyable(                                                               \

   649         boost::foreach_detail_::to_ptr(COL)                                                     \

   650       , boost_foreach_argument_dependent_lookup_hack_value)

   652 // returns true_* if the type is a lightweight proxy (and is not noncopyable)

   653 #define BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                                 \

   654     boost::foreach_detail_::and_(                                                               \

   655         boost::foreach_detail_::not_(BOOST_FOREACH_IS_NONCOPYABLE(COL))                         \

   656       , boost_foreach_is_lightweight_proxy(                                                     \

   657             boost::foreach_detail_::to_ptr(COL)                                                 \

   658           , boost_foreach_argument_dependent_lookup_hack_value))

   660 #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION

   661 ///////////////////////////////////////////////////////////////////////////////

   662 // R-values and const R-values supported here with zero runtime overhead

   663 ///////////////////////////////////////////////////////////////////////////////

   665 // No variable is needed to track the rvalue-ness of the collection expression

   666 # define BOOST_FOREACH_PREAMBLE()                                                               \

   667     /**/

   669 // Evaluate the collection expression

   670 # define BOOST_FOREACH_EVALUATE(COL)                                                            \

   671     (COL)

   673 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \

   674     (true ? 0 : boost::foreach_detail_::or_(                                                    \

   675         BOOST_FOREACH_IS_RVALUE(COL)                                                            \

   676       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))

   678 #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)

   679 ///////////////////////////////////////////////////////////////////////////////

   680 // R-values and const R-values supported here

   681 ///////////////////////////////////////////////////////////////////////////////

   683 // Declare a variable to track the rvalue-ness of the collection expression

   684 # define BOOST_FOREACH_PREAMBLE()                                                               \

   685     if (bool _foreach_is_rvalue = false) {} else

   687 // Evaluate the collection expression, and detect if it is an lvalue or and rvalue

   688 # define BOOST_FOREACH_EVALUATE(COL)                                                            \

   689     (true ? boost::foreach_detail_::make_probe((COL), _foreach_is_rvalue) : (COL))

   691 // The rvalue/lvalue-ness of the collection expression is determined dynamically, unless

   692 // type type is an array or is noncopyable or is non-const, in which case we know it's an lvalue.

   693 // If the type happens to be a lightweight proxy, always make a copy.

   694 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \

   695     (boost::foreach_detail_::should_copy_impl(                                                  \

   696         true ? 0 : boost::foreach_detail_::or_(                                                 \

   697             boost::foreach_detail_::is_array_(COL)                                              \

   698           , BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                   \

   699           , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(COL)))               \

   700       , true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                      \

   701       , &_foreach_is_rvalue))

   703 #elif !defined(BOOST_FOREACH_NO_RVALUE_DETECTION)

   704 ///////////////////////////////////////////////////////////////////////////////

   705 // R-values supported here, const R-values NOT supported here

   706 ///////////////////////////////////////////////////////////////////////////////

   708 // No variable is needed to track the rvalue-ness of the collection expression

   709 # define BOOST_FOREACH_PREAMBLE()                                                               \

   710     /**/

   712 // Evaluate the collection expression

   713 # define BOOST_FOREACH_EVALUATE(COL)                                                            \

   714     (COL)

   716 // Determine whether the collection expression is an lvalue or an rvalue.

   717 // NOTE: this gets the answer wrong for const rvalues.

   718 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \

   719     (true ? 0 : boost::foreach_detail_::or_(                                                    \

   720         boost::foreach_detail_::is_rvalue_((COL), 0)                                            \

   721       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))

   723 #else

   724 ///////////////////////////////////////////////////////////////////////////////

   725 // R-values NOT supported here

   726 ///////////////////////////////////////////////////////////////////////////////

   728 // No variable is needed to track the rvalue-ness of the collection expression

   729 # define BOOST_FOREACH_PREAMBLE()                                                               \

   730     /**/

   732 // Evaluate the collection expression

   733 # define BOOST_FOREACH_EVALUATE(COL)                                                            \

   734     (COL)

   736 // Can't use rvalues with BOOST_FOREACH (unless they are lightweight proxies)

   737 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \

   738     (true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))

   740 #endif

   742 #define BOOST_FOREACH_CONTAIN(COL)                                                              \

   743     boost::foreach_detail_::contain(                                                            \

   744         BOOST_FOREACH_EVALUATE(COL)                                                             \

   745       , BOOST_FOREACH_SHOULD_COPY(COL))

   747 #define BOOST_FOREACH_BEGIN(COL)                                                                \

   748     boost::foreach_detail_::begin(                                                              \

   749         _foreach_col                                                                            \

   750       , BOOST_FOREACH_TYPEOF(COL)                                                               \

   751       , BOOST_FOREACH_SHOULD_COPY(COL))

   753 #define BOOST_FOREACH_END(COL)                                                                  \

   754     boost::foreach_detail_::end(                                                                \

   755         _foreach_col                                                                            \

   756       , BOOST_FOREACH_TYPEOF(COL)                                                               \

   757       , BOOST_FOREACH_SHOULD_COPY(COL))

   759 #define BOOST_FOREACH_DONE(COL)                                                                 \

   760     boost::foreach_detail_::done(                                                               \

   761         _foreach_cur                                                                            \

   762       , _foreach_end                                                                            \

   763       , BOOST_FOREACH_TYPEOF(COL))

   765 #define BOOST_FOREACH_NEXT(COL)                                                                 \

   766     boost::foreach_detail_::next(                                                               \

   767         _foreach_cur                                                                            \

   768       , BOOST_FOREACH_TYPEOF(COL))

   770 #define BOOST_FOREACH_DEREF(COL)                                                                \

   771     boost::foreach_detail_::deref(                                                              \

   772         _foreach_cur                                                                            \

   773       , BOOST_FOREACH_TYPEOF(COL))

   775 ///////////////////////////////////////////////////////////////////////////////

   776 // BOOST_FOREACH

   777 //

   778 //   For iterating over collections. Collections can be

   779 //   arrays, null-terminated strings, or STL containers.

   780 //   The loop variable can be a value or reference. For

   781 //   example:

   782 //

   783 //   std::list<int> int_list(/*stuff*/);

   784 //   BOOST_FOREACH(int &i, int_list)

   785 //   {

   786 //       /*

   787 //        * loop body goes here.

   788 //        * i is a reference to the int in int_list.

   789 //        */

   790 //   }

   791 //

   792 //   Alternately, you can declare the loop variable first,

   793 //   so you can access it after the loop finishes. Obviously,

   794 //   if you do it this way, then the loop variable cannot be

   795 //   a reference.

   796 //

   797 //   int i;

   798 //   BOOST_FOREACH(i, int_list)

   799 //       { ... }

   800 //

   801 #define BOOST_FOREACH(VAR, COL)                                                                 \

   802     BOOST_FOREACH_PREAMBLE()                                                                    \

   803     if (boost::foreach_detail_::auto_any_t _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \

   804     if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_BEGIN(COL)) {} else     \

   805     if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_END(COL)) {} else       \

   806     for (bool _foreach_continue = true;                                                         \

   807               _foreach_continue && !BOOST_FOREACH_DONE(COL);                                    \

   808               _foreach_continue ? BOOST_FOREACH_NEXT(COL) : (void)0)                            \

   809         if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \

   810         for (VAR = BOOST_FOREACH_DEREF(COL); !_foreach_continue; _foreach_continue = true)

   812 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--