| /////////////////////////////////////////////////////////////////////////////// |
| // foreach.hpp header file |
| // |
| // Copyright 2004 Eric Niebler. |
| // 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) |
| // See http://www.boost.org/libs/foreach for documentation |
| // |
| // Credits: |
| // Anson Tsao - for the initial inspiration and several good suggestions. |
| // Thorsten Ottosen - for Boost.Range, and for suggesting a way to detect |
| // const-qualified rvalues at compile time on VC7.1+ |
| // Russell Hind - For help porting to Borland |
| // Alisdair Meredith - For help porting to Borland |
| // Stefan Slapeta - For help porting to Intel |
| // David Jenkins - For help finding a Microsoft Code Analysis bug |
| |
| #ifndef BOOST_FOREACH |
| |
| // MS compatible compilers support #pragma once |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| # pragma once |
| #endif |
| |
| #include <cstddef> |
| #include <utility> // for std::pair |
| |
| #include <boost/config.hpp> |
| #include <boost/detail/workaround.hpp> |
| |
| // Some compilers let us detect even const-qualified rvalues at compile-time |
| #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310) && !defined(_PREFAST_) \ |
| || (BOOST_WORKAROUND(__GNUC__, >= 4) && !defined(BOOST_INTEL) && !defined(BOOST_CLANG)) \ |
| || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL) && \ |
| !defined(BOOST_CLANG)) |
| # define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION |
| #else |
| // Some compilers allow temporaries to be bound to non-const references. |
| // These compilers make it impossible to for BOOST_FOREACH to detect |
| // temporaries and avoid reevaluation of the collection expression. |
| # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ |
| || BOOST_WORKAROUND(__BORLANDC__, < 0x593) \ |
| || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ |
| || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \ |
| || BOOST_WORKAROUND(__DECCXX_VER, <= 60590042) |
| # define BOOST_FOREACH_NO_RVALUE_DETECTION |
| # endif |
| // Some compilers do not correctly implement the lvalue/rvalue conversion |
| // rules of the ternary conditional operator. |
| # if defined(BOOST_FOREACH_NO_RVALUE_DETECTION) \ |
| || defined(BOOST_NO_SFINAE) \ |
| || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ |
| || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1400)) \ |
| || BOOST_WORKAROUND(__GNUC__, < 3) \ |
| || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2)) \ |
| || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__)) \ |
| || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ |
| || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) \ |
| || BOOST_WORKAROUND(__SUNPRO_CC, >= 0x5100) \ |
| || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x590)) |
| # define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION |
| # else |
| # define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| # endif |
| #endif |
| |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/assert.hpp> |
| #include <boost/mpl/logical.hpp> |
| #include <boost/mpl/eval_if.hpp> |
| #include <boost/noncopyable.hpp> |
| #include <boost/range/end.hpp> |
| #include <boost/range/begin.hpp> |
| #include <boost/range/rend.hpp> |
| #include <boost/range/rbegin.hpp> |
| #include <boost/range/iterator.hpp> |
| #include <boost/range/reverse_iterator.hpp> |
| #include <boost/type_traits/is_array.hpp> |
| #include <boost/type_traits/is_const.hpp> |
| #include <boost/type_traits/is_abstract.hpp> |
| #include <boost/type_traits/is_base_and_derived.hpp> |
| #include <boost/iterator/iterator_traits.hpp> |
| #include <boost/utility/addressof.hpp> |
| #include <boost/foreach_fwd.hpp> |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| # include <new> |
| # include <boost/aligned_storage.hpp> |
| # include <boost/utility/enable_if.hpp> |
| # include <boost/type_traits/remove_const.hpp> |
| #endif |
| |
| namespace boost |
| { |
| |
| // forward declarations for iterator_range |
| template<typename T> |
| class iterator_range; |
| |
| // forward declarations for sub_range |
| template<typename T> |
| class sub_range; |
| |
| namespace foreach |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // in_range |
| // |
| template<typename T> |
| inline std::pair<T, T> in_range(T begin, T end) |
| { |
| return std::make_pair(begin, end); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // boost::foreach::is_lightweight_proxy |
| // Specialize this for user-defined collection types if they are inexpensive to copy. |
| // This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff. |
| template<typename T> |
| struct is_lightweight_proxy |
| : boost::mpl::false_ |
| { |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // boost::foreach::is_noncopyable |
| // Specialize this for user-defined collection types if they cannot be copied. |
| // This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff. |
| template<typename T> |
| struct is_noncopyable |
| #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT) |
| : boost::mpl::or_< |
| boost::is_abstract<T> |
| , boost::is_base_and_derived<boost::noncopyable, T> |
| > |
| #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) |
| : boost::is_base_and_derived<boost::noncopyable, T> |
| #elif !defined(BOOST_NO_IS_ABSTRACT) |
| : boost::is_abstract<T> |
| #else |
| : boost::mpl::false_ |
| #endif |
| { |
| }; |
| |
| } // namespace foreach |
| |
| } // namespace boost |
| |
| // vc6/7 needs help ordering the following overloads |
| #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| # define BOOST_FOREACH_TAG_DEFAULT ... |
| #else |
| # define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // boost_foreach_is_lightweight_proxy |
| // Another customization point for the is_lightweight_proxy optimization, |
| // this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy |
| // at the global namespace for your type. |
| template<typename T> |
| inline boost::foreach::is_lightweight_proxy<T> * |
| boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::true_ * |
| boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::true_ * |
| boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::true_ * |
| boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::true_ * |
| boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // boost_foreach_is_noncopyable |
| // Another customization point for the is_noncopyable trait, |
| // this one works on legacy compilers. Overload boost_foreach_is_noncopyable |
| // at the global namespace for your type. |
| template<typename T> |
| inline boost::foreach::is_noncopyable<T> * |
| boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } |
| |
| namespace boost |
| { |
| |
| namespace foreach_detail_ |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Define some utilities for assessing the properties of expressions |
| // |
| template<typename Bool1, typename Bool2> |
| inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; } |
| |
| template<typename Bool1, typename Bool2, typename Bool3> |
| inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; } |
| |
| template<typename Bool1, typename Bool2> |
| inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; } |
| |
| template<typename Bool1, typename Bool2, typename Bool3> |
| inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; } |
| |
| template<typename Bool1> |
| inline boost::mpl::not_<Bool1> *not_(Bool1 *) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; } |
| |
| template<typename T> |
| inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; } |
| |
| template<typename T> |
| inline boost::is_array<T> *is_array_(T const &) { return 0; } |
| |
| template<typename T> |
| inline boost::is_const<T> *is_const_(T &) { return 0; } |
| |
| #ifndef BOOST_FOREACH_NO_RVALUE_DETECTION |
| template<typename T> |
| inline boost::mpl::true_ *is_const_(T const &) { return 0; } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // auto_any_t/auto_any |
| // General utility for putting an object of any type into automatic storage |
| struct auto_any_base |
| { |
| // auto_any_base must evaluate to false in boolean context so that |
| // they can be declared in if() statements. |
| operator bool() const |
| { |
| return false; |
| } |
| }; |
| |
| template<typename T> |
| struct auto_any : auto_any_base |
| { |
| explicit auto_any(T const &t) |
| : item(t) |
| { |
| } |
| |
| // temporaries of type auto_any will be bound to const auto_any_base |
| // references, but we still want to be able to mutate the stored |
| // data, so declare it as mutable. |
| mutable T item; |
| }; |
| |
| typedef auto_any_base const &auto_any_t; |
| |
| template<typename T, typename C> |
| inline BOOST_DEDUCED_TYPENAME boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a) |
| { |
| return static_cast<auto_any<T> const &>(a).item; |
| } |
| |
| typedef boost::mpl::true_ const_; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // type2type |
| // |
| template<typename T, typename C = boost::mpl::false_> |
| struct type2type |
| : boost::mpl::if_<C, T const, T> |
| { |
| }; |
| |
| template<typename T> |
| struct wrap_cstr |
| { |
| typedef T type; |
| }; |
| |
| template<> |
| struct wrap_cstr<char *> |
| { |
| typedef wrap_cstr<char *> type; |
| typedef char *iterator; |
| typedef char *const_iterator; |
| }; |
| |
| template<> |
| struct wrap_cstr<char const *> |
| { |
| typedef wrap_cstr<char const *> type; |
| typedef char const *iterator; |
| typedef char const *const_iterator; |
| }; |
| |
| template<> |
| struct wrap_cstr<wchar_t *> |
| { |
| typedef wrap_cstr<wchar_t *> type; |
| typedef wchar_t *iterator; |
| typedef wchar_t *const_iterator; |
| }; |
| |
| template<> |
| struct wrap_cstr<wchar_t const *> |
| { |
| typedef wrap_cstr<wchar_t const *> type; |
| typedef wchar_t const *iterator; |
| typedef wchar_t const *const_iterator; |
| }; |
| |
| template<typename T> |
| struct is_char_array |
| : mpl::and_< |
| is_array<T> |
| , mpl::or_< |
| is_convertible<T, char const *> |
| , is_convertible<T, wchar_t const *> |
| > |
| > |
| {}; |
| |
| template<typename T, typename C = boost::mpl::false_> |
| struct foreach_iterator |
| { |
| // **** READ THIS IF YOUR COMPILE BREAKS HERE **** |
| // |
| // There is an ambiguity about how to iterate over arrays of char and wchar_t. |
| // Should the last array element be treated as a null terminator to be skipped, or |
| // is it just like any other element in the array? To fix the problem, you must |
| // say which behavior you want. |
| // |
| // To treat the container as a null-terminated string, merely cast it to a |
| // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... |
| // |
| // To treat the container as an array, use boost::as_array() in <boost/range/as_array.hpp>, |
| // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); |
| #endif |
| |
| // If the type is a pointer to a null terminated string (as opposed |
| // to an array type), there is no ambiguity. |
| typedef BOOST_DEDUCED_TYPENAME wrap_cstr<T>::type container; |
| |
| typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< |
| C |
| , range_const_iterator<container> |
| , range_mutable_iterator<container> |
| >::type type; |
| }; |
| |
| |
| template<typename T, typename C = boost::mpl::false_> |
| struct foreach_reverse_iterator |
| { |
| // **** READ THIS IF YOUR COMPILE BREAKS HERE **** |
| // |
| // There is an ambiguity about how to iterate over arrays of char and wchar_t. |
| // Should the last array element be treated as a null terminator to be skipped, or |
| // is it just like any other element in the array? To fix the problem, you must |
| // say which behavior you want. |
| // |
| // To treat the container as a null-terminated string, merely cast it to a |
| // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... |
| // |
| // To treat the container as an array, use boost::as_array() in <boost/range/as_array.hpp>, |
| // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); |
| #endif |
| |
| // If the type is a pointer to a null terminated string (as opposed |
| // to an array type), there is no ambiguity. |
| typedef BOOST_DEDUCED_TYPENAME wrap_cstr<T>::type container; |
| |
| typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< |
| C |
| , range_reverse_iterator<container const> |
| , range_reverse_iterator<container> |
| >::type type; |
| }; |
| |
| template<typename T, typename C = boost::mpl::false_> |
| struct foreach_reference |
| : iterator_reference<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type> |
| { |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // encode_type |
| // |
| template<typename T> |
| inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; } |
| |
| template<typename T> |
| inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // set_false |
| // |
| inline bool set_false(bool &b) |
| { |
| b = false; |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // to_ptr |
| // |
| template<typename T> |
| inline T *&to_ptr(T const &) |
| { |
| static T *t = 0; |
| return t; |
| } |
| |
| // Borland needs a little extra help with arrays |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
| template<typename T,std::size_t N> |
| inline T (*&to_ptr(T (&)[N]))[N] |
| { |
| static T (*t)[N] = 0; |
| return t; |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // derefof |
| // |
| template<typename T> |
| inline T &derefof(T *t) |
| { |
| // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N], |
| // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue. |
| return reinterpret_cast<T &>( |
| *const_cast<char *>( |
| reinterpret_cast<char const volatile *>(t) |
| ) |
| ); |
| } |
| |
| #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION |
| /////////////////////////////////////////////////////////////////////////////// |
| // Detect at compile-time whether an expression yields an rvalue or |
| // an lvalue. This is rather non-standard, but some popular compilers |
| // accept it. |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rvalue_probe |
| // |
| template<typename T> |
| struct rvalue_probe |
| { |
| struct private_type_ {}; |
| // can't ever return an array by value |
| typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< |
| boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T |
| >::type value_type; |
| operator value_type() { return *reinterpret_cast<value_type *>(this); } // never called |
| operator T &() const { return *reinterpret_cast<T *>(const_cast<rvalue_probe *>(this)); } // never called |
| }; |
| |
| template<typename T> |
| rvalue_probe<T> const make_probe(T const &) |
| { |
| return rvalue_probe<T>(); |
| } |
| |
| # define BOOST_FOREACH_IS_RVALUE(COL) \ |
| boost::foreach_detail_::and_( \ |
| boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL)) \ |
| , (true ? 0 : boost::foreach_detail_::is_rvalue_( \ |
| (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0))) |
| |
| #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION) |
| /////////////////////////////////////////////////////////////////////////////// |
| // Detect at run-time whether an expression yields an rvalue |
| // or an lvalue. This is 100% standard C++, but not all compilers |
| // accept it. Also, it causes FOREACH to break when used with non- |
| // copyable collection types. |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rvalue_probe |
| // |
| template<typename T> |
| struct rvalue_probe |
| { |
| rvalue_probe(T &t, bool &b) |
| : value(t) |
| , is_rvalue(b) |
| { |
| } |
| |
| struct private_type_ {}; |
| // can't ever return an array or an abstract type by value |
| #ifdef BOOST_NO_IS_ABSTRACT |
| typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< |
| boost::is_array<T>, private_type_, T |
| >::type value_type; |
| #else |
| typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< |
| boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T |
| >::type value_type; |
| #endif |
| |
| operator value_type() |
| { |
| this->is_rvalue = true; |
| return this->value; |
| } |
| |
| operator T &() const |
| { |
| return this->value; |
| } |
| |
| private: |
| T &value; |
| bool &is_rvalue; |
| }; |
| |
| template<typename T> |
| rvalue_probe<T> make_probe(T &t, bool &b) { return rvalue_probe<T>(t, b); } |
| |
| template<typename T> |
| rvalue_probe<T const> make_probe(T const &t, bool &b) { return rvalue_probe<T const>(t, b); } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // simple_variant |
| // holds either a T or a T const* |
| template<typename T> |
| struct simple_variant |
| { |
| simple_variant(T const *t) |
| : is_rvalue(false) |
| { |
| *static_cast<T const **>(this->data.address()) = t; |
| } |
| |
| simple_variant(T const &t) |
| : is_rvalue(true) |
| { |
| ::new(this->data.address()) T(t); |
| } |
| |
| simple_variant(simple_variant const &that) |
| : is_rvalue(that.is_rvalue) |
| { |
| if(this->is_rvalue) |
| ::new(this->data.address()) T(*that.get()); |
| else |
| *static_cast<T const **>(this->data.address()) = that.get(); |
| } |
| |
| ~simple_variant() |
| { |
| if(this->is_rvalue) |
| this->get()->~T(); |
| } |
| |
| T const *get() const |
| { |
| if(this->is_rvalue) |
| return static_cast<T const *>(this->data.address()); |
| else |
| return *static_cast<T const * const *>(this->data.address()); |
| } |
| |
| private: |
| enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) }; |
| simple_variant &operator =(simple_variant const &); |
| bool const is_rvalue; |
| aligned_storage<size> data; |
| }; |
| |
| // If the collection is an array or is noncopyable, it must be an lvalue. |
| // If the collection is a lightweight proxy, treat it as an rvalue |
| // BUGBUG what about a noncopyable proxy? |
| template<typename LValue, typename IsProxy> |
| inline BOOST_DEDUCED_TYPENAME boost::enable_if<boost::mpl::or_<LValue, IsProxy>, IsProxy>::type * |
| should_copy_impl(LValue *, IsProxy *, bool *) |
| { |
| return 0; |
| } |
| |
| // Otherwise, we must determine at runtime whether it's an lvalue or rvalue |
| inline bool * |
| should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue) |
| { |
| return is_rvalue; |
| } |
| |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // contain |
| // |
| template<typename T> |
| inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue |
| { |
| return auto_any<T>(t); |
| } |
| |
| template<typename T> |
| inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue |
| { |
| // Cannot seem to get sunpro to handle addressof() with array types. |
| #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570)) |
| return auto_any<T *>(&t); |
| #else |
| return auto_any<T *>(boost::addressof(t)); |
| #endif |
| } |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| template<typename T> |
| inline auto_any<simple_variant<T> > |
| contain(T const &t, bool *rvalue) |
| { |
| return auto_any<simple_variant<T> >(*rvalue ? simple_variant<T>(t) : simple_variant<T>(&t)); |
| } |
| #endif |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // begin |
| // |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type> |
| begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>( |
| boost::begin(auto_any_cast<T, C>(col))); |
| } |
| |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type> |
| begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue |
| { |
| typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type; |
| typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator; |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>( |
| iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))))); |
| } |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| template<typename T> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type> |
| begin(auto_any_t col, type2type<T, const_> *, bool *) |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>( |
| boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get())); |
| } |
| #endif |
| |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| template<typename T, typename C> |
| inline auto_any<T *> |
| begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings |
| { |
| return auto_any<T *>(auto_any_cast<T *, boost::mpl::false_>(col)); |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // end |
| // |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type> |
| end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>( |
| boost::end(auto_any_cast<T, C>(col))); |
| } |
| |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type> |
| end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue |
| { |
| typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type; |
| typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator; |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>( |
| iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))))); |
| } |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| template<typename T> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type> |
| end(auto_any_t col, type2type<T, const_> *, bool *) |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>( |
| boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get())); |
| } |
| #endif |
| |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| template<typename T, typename C> |
| inline auto_any<int> |
| end(auto_any_t, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings |
| { |
| return auto_any<int>(0); // not used |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // done |
| // |
| template<typename T, typename C> |
| inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t; |
| return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end); |
| } |
| |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| template<typename T, typename C> |
| inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *) // null-terminated C-style strings |
| { |
| return ! *auto_any_cast<T *, boost::mpl::false_>(cur); |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // next |
| // |
| template<typename T, typename C> |
| inline void next(auto_any_t cur, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t; |
| ++auto_any_cast<iter_t, boost::mpl::false_>(cur); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // deref |
| // |
| template<typename T, typename C> |
| inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type |
| deref(auto_any_t cur, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t; |
| return *auto_any_cast<iter_t, boost::mpl::false_>(cur); |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // rbegin |
| // |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type> |
| rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>( |
| boost::rbegin(auto_any_cast<T, C>(col))); |
| } |
| |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type> |
| rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue |
| { |
| typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type; |
| typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator; |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>( |
| iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))))); |
| } |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| template<typename T> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type> |
| rbegin(auto_any_t col, type2type<T, const_> *, bool *) |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>( |
| boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get())); |
| } |
| #endif |
| |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| template<typename T, typename C> |
| inline auto_any<reverse_iterator<T *> > |
| rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings |
| { |
| T *p = auto_any_cast<T *, boost::mpl::false_>(col); |
| while(0 != *p) |
| ++p; |
| return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p)); |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rend |
| // |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type> |
| rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>( |
| boost::rend(auto_any_cast<T, C>(col))); |
| } |
| |
| template<typename T, typename C> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type> |
| rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue |
| { |
| typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type; |
| typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator; |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>( |
| iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))))); |
| } |
| |
| #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION |
| template<typename T> |
| inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type> |
| rend(auto_any_t col, type2type<T, const_> *, bool *) |
| { |
| return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>( |
| boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get())); |
| } |
| #endif |
| |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| template<typename T, typename C> |
| inline auto_any<reverse_iterator<T *> > |
| rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings |
| { |
| return auto_any<reverse_iterator<T *> >( |
| reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col))); |
| } |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rdone |
| // |
| template<typename T, typename C> |
| inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t; |
| return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rnext |
| // |
| template<typename T, typename C> |
| inline void rnext(auto_any_t cur, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t; |
| ++auto_any_cast<iter_t, boost::mpl::false_>(cur); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // rderef |
| // |
| template<typename T, typename C> |
| inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type |
| rderef(auto_any_t cur, type2type<T, C> *) |
| { |
| typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t; |
| return *auto_any_cast<iter_t, boost::mpl::false_>(cur); |
| } |
| |
| } // namespace foreach_detail_ |
| } // namespace boost |
| |
| // Suppress a bogus code analysis warning on vc8+ |
| #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) |
| # define BOOST_FOREACH_SUPPRESS_WARNINGS() __pragma(warning(suppress:6001)) |
| #else |
| # define BOOST_FOREACH_SUPPRESS_WARNINGS() |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Define a macro for giving hidden variables a unique name. Not strictly |
| // needed, but eliminates some warnings on some compilers. |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) |
| // With some versions of MSVC, use of __LINE__ to create unique identifiers |
| // can fail when the Edit-and-Continue debug flag is used. |
| # define BOOST_FOREACH_ID(x) x |
| #else |
| # define BOOST_FOREACH_ID(x) BOOST_PP_CAT(x, __LINE__) |
| #endif |
| |
| // A sneaky way to get the type of the collection without evaluating the expression |
| #define BOOST_FOREACH_TYPEOF(COL) \ |
| (true ? 0 : boost::foreach_detail_::encode_type(COL, boost::foreach_detail_::is_const_(COL))) |
| |
| // returns true_* if the type is noncopyable |
| #define BOOST_FOREACH_IS_NONCOPYABLE(COL) \ |
| boost_foreach_is_noncopyable( \ |
| boost::foreach_detail_::to_ptr(COL) \ |
| , boost_foreach_argument_dependent_lookup_hack_value) |
| |
| // returns true_* if the type is a lightweight proxy (and is not noncopyable) |
| #define BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL) \ |
| boost::foreach_detail_::and_( \ |
| boost::foreach_detail_::not_(BOOST_FOREACH_IS_NONCOPYABLE(COL)) \ |
| , boost_foreach_is_lightweight_proxy( \ |
| boost::foreach_detail_::to_ptr(COL) \ |
| , boost_foreach_argument_dependent_lookup_hack_value)) |
| |
| #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION |
| /////////////////////////////////////////////////////////////////////////////// |
| // R-values and const R-values supported here with zero runtime overhead |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // No variable is needed to track the rvalue-ness of the collection expression |
| # define BOOST_FOREACH_PREAMBLE() \ |
| BOOST_FOREACH_SUPPRESS_WARNINGS() |
| |
| // Evaluate the collection expression |
| # define BOOST_FOREACH_EVALUATE(COL) \ |
| (COL) |
| |
| # define BOOST_FOREACH_SHOULD_COPY(COL) \ |
| (true ? 0 : boost::foreach_detail_::or_( \ |
| BOOST_FOREACH_IS_RVALUE(COL) \ |
| , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))) |
| |
| #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION) |
| /////////////////////////////////////////////////////////////////////////////// |
| // R-values and const R-values supported here |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // Declare a variable to track the rvalue-ness of the collection expression |
| # define BOOST_FOREACH_PREAMBLE() \ |
| BOOST_FOREACH_SUPPRESS_WARNINGS() \ |
| if (bool BOOST_FOREACH_ID(_foreach_is_rvalue) = false) {} else |
| |
| // Evaluate the collection expression, and detect if it is an lvalue or and rvalue |
| # define BOOST_FOREACH_EVALUATE(COL) \ |
| (true ? boost::foreach_detail_::make_probe((COL), BOOST_FOREACH_ID(_foreach_is_rvalue)) : (COL)) |
| |
| // The rvalue/lvalue-ness of the collection expression is determined dynamically, unless |
| // type type is an array or is noncopyable or is non-const, in which case we know it's an lvalue. |
| // If the type happens to be a lightweight proxy, always make a copy. |
| # define BOOST_FOREACH_SHOULD_COPY(COL) \ |
| (boost::foreach_detail_::should_copy_impl( \ |
| true ? 0 : boost::foreach_detail_::or_( \ |
| boost::foreach_detail_::is_array_(COL) \ |
| , BOOST_FOREACH_IS_NONCOPYABLE(COL) \ |
| , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(COL))) \ |
| , true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL) \ |
| , &BOOST_FOREACH_ID(_foreach_is_rvalue))) |
| |
| #elif !defined(BOOST_FOREACH_NO_RVALUE_DETECTION) |
| /////////////////////////////////////////////////////////////////////////////// |
| // R-values supported here, const R-values NOT supported here |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // No variable is needed to track the rvalue-ness of the collection expression |
| # define BOOST_FOREACH_PREAMBLE() \ |
| BOOST_FOREACH_SUPPRESS_WARNINGS() |
| |
| // Evaluate the collection expression |
| # define BOOST_FOREACH_EVALUATE(COL) \ |
| (COL) |
| |
| // Determine whether the collection expression is an lvalue or an rvalue. |
| // NOTE: this gets the answer wrong for const rvalues. |
| # define BOOST_FOREACH_SHOULD_COPY(COL) \ |
| (true ? 0 : boost::foreach_detail_::or_( \ |
| boost::foreach_detail_::is_rvalue_((COL), 0) \ |
| , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))) |
| |
| #else |
| /////////////////////////////////////////////////////////////////////////////// |
| // R-values NOT supported here |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // No variable is needed to track the rvalue-ness of the collection expression |
| # define BOOST_FOREACH_PREAMBLE() \ |
| BOOST_FOREACH_SUPPRESS_WARNINGS() |
| |
| // Evaluate the collection expression |
| # define BOOST_FOREACH_EVALUATE(COL) \ |
| (COL) |
| |
| // Can't use rvalues with BOOST_FOREACH (unless they are lightweight proxies) |
| # define BOOST_FOREACH_SHOULD_COPY(COL) \ |
| (true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)) |
| |
| #endif |
| |
| #define BOOST_FOREACH_CONTAIN(COL) \ |
| boost::foreach_detail_::contain( \ |
| BOOST_FOREACH_EVALUATE(COL) \ |
| , BOOST_FOREACH_SHOULD_COPY(COL)) |
| |
| #define BOOST_FOREACH_BEGIN(COL) \ |
| boost::foreach_detail_::begin( \ |
| BOOST_FOREACH_ID(_foreach_col) \ |
| , BOOST_FOREACH_TYPEOF(COL) \ |
| , BOOST_FOREACH_SHOULD_COPY(COL)) |
| |
| #define BOOST_FOREACH_END(COL) \ |
| boost::foreach_detail_::end( \ |
| BOOST_FOREACH_ID(_foreach_col) \ |
| , BOOST_FOREACH_TYPEOF(COL) \ |
| , BOOST_FOREACH_SHOULD_COPY(COL)) |
| |
| #define BOOST_FOREACH_DONE(COL) \ |
| boost::foreach_detail_::done( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_ID(_foreach_end) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| #define BOOST_FOREACH_NEXT(COL) \ |
| boost::foreach_detail_::next( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| #define BOOST_FOREACH_DEREF(COL) \ |
| boost::foreach_detail_::deref( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| #define BOOST_FOREACH_RBEGIN(COL) \ |
| boost::foreach_detail_::rbegin( \ |
| BOOST_FOREACH_ID(_foreach_col) \ |
| , BOOST_FOREACH_TYPEOF(COL) \ |
| , BOOST_FOREACH_SHOULD_COPY(COL)) |
| |
| #define BOOST_FOREACH_REND(COL) \ |
| boost::foreach_detail_::rend( \ |
| BOOST_FOREACH_ID(_foreach_col) \ |
| , BOOST_FOREACH_TYPEOF(COL) \ |
| , BOOST_FOREACH_SHOULD_COPY(COL)) |
| |
| #define BOOST_FOREACH_RDONE(COL) \ |
| boost::foreach_detail_::rdone( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_ID(_foreach_end) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| #define BOOST_FOREACH_RNEXT(COL) \ |
| boost::foreach_detail_::rnext( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| #define BOOST_FOREACH_RDEREF(COL) \ |
| boost::foreach_detail_::rderef( \ |
| BOOST_FOREACH_ID(_foreach_cur) \ |
| , BOOST_FOREACH_TYPEOF(COL)) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // BOOST_FOREACH |
| // |
| // For iterating over collections. Collections can be |
| // arrays, null-terminated strings, or STL containers. |
| // The loop variable can be a value or reference. For |
| // example: |
| // |
| // std::list<int> int_list(/*stuff*/); |
| // BOOST_FOREACH(int &i, int_list) |
| // { |
| // /* |
| // * loop body goes here. |
| // * i is a reference to the int in int_list. |
| // */ |
| // } |
| // |
| // Alternately, you can declare the loop variable first, |
| // so you can access it after the loop finishes. Obviously, |
| // if you do it this way, then the loop variable cannot be |
| // a reference. |
| // |
| // int i; |
| // BOOST_FOREACH(i, int_list) |
| // { ... } |
| // |
| #define BOOST_FOREACH(VAR, COL) \ |
| BOOST_FOREACH_PREAMBLE() \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_col) = BOOST_FOREACH_CONTAIN(COL)) {} else \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_BEGIN(COL)) {} else \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_END(COL)) {} else \ |
| for (bool BOOST_FOREACH_ID(_foreach_continue) = true; \ |
| BOOST_FOREACH_ID(_foreach_continue) && !BOOST_FOREACH_DONE(COL); \ |
| BOOST_FOREACH_ID(_foreach_continue) ? BOOST_FOREACH_NEXT(COL) : (void)0) \ |
| if (boost::foreach_detail_::set_false(BOOST_FOREACH_ID(_foreach_continue))) {} else \ |
| for (VAR = BOOST_FOREACH_DEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // BOOST_REVERSE_FOREACH |
| // |
| // For iterating over collections in reverse order. In |
| // all other respects, BOOST_REVERSE_FOREACH is like |
| // BOOST_FOREACH. |
| // |
| #define BOOST_REVERSE_FOREACH(VAR, COL) \ |
| BOOST_FOREACH_PREAMBLE() \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_col) = BOOST_FOREACH_CONTAIN(COL)) {} else \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_RBEGIN(COL)) {} else \ |
| if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_REND(COL)) {} else \ |
| for (bool BOOST_FOREACH_ID(_foreach_continue) = true; \ |
| BOOST_FOREACH_ID(_foreach_continue) && !BOOST_FOREACH_RDONE(COL); \ |
| BOOST_FOREACH_ID(_foreach_continue) ? BOOST_FOREACH_RNEXT(COL) : (void)0) \ |
| if (boost::foreach_detail_::set_false(BOOST_FOREACH_ID(_foreach_continue))) {} else \ |
| for (VAR = BOOST_FOREACH_RDEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true) |
| |
| #endif |