sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // foreach.hpp header file
sl@0: //
sl@0: // Copyright 2004 Eric Niebler.
sl@0: // Distributed under the Boost Software License, Version 1.0. (See
sl@0: // accompanying file LICENSE_1_0.txt or copy at
sl@0: // http://www.boost.org/LICENSE_1_0.txt)
sl@0: //
sl@0: // Credits:
sl@0: //  Anson Tsao        - for the initial inspiration and several good suggestions.
sl@0: //  Thorsten Ottosen  - for Boost.Range, and for suggesting a way to detect
sl@0: //                      const-qualified rvalues at compile time on VC7.1+
sl@0: //  Russell Hind      - For help porting to Borland
sl@0: //  Alisdair Meredith - For help porting to Borland
sl@0: //  Stefan Slapeta    - For help porting to Intel
sl@0: 
sl@0: #ifndef BOOST_FOREACH
sl@0: 
sl@0: // MS compatible compilers support #pragma once
sl@0: #if defined(_MSC_VER) && (_MSC_VER >= 1020)
sl@0: # pragma once
sl@0: #endif
sl@0: 
sl@0: #include <cstddef>
sl@0: #include <utility>  // for std::pair
sl@0: 
sl@0: #include <boost/config.hpp>
sl@0: #include <boost/detail/workaround.hpp>
sl@0: 
sl@0: // Some compilers let us detect even const-qualified rvalues at compile-time
sl@0: #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)                                                       \
sl@0:  || (BOOST_WORKAROUND(__GNUC__, >= 4) && !defined(BOOST_INTEL))                                 \
sl@0:  || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL))
sl@0: # define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION
sl@0: #else
sl@0: // Some compilers allow temporaries to be bound to non-const references.
sl@0: // These compilers make it impossible to for BOOST_FOREACH to detect
sl@0: // temporaries and avoid reevaluation of the collection expression.
sl@0: # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                                      \
sl@0:   || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))                                     \
sl@0:   || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))                   \
sl@0:   || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))                                      \
sl@0:   || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
sl@0: #  define BOOST_FOREACH_NO_RVALUE_DETECTION
sl@0: # endif
sl@0: // Some compilers do not correctly implement the lvalue/rvalue conversion
sl@0: // rules of the ternary conditional operator.
sl@0: # if defined(BOOST_FOREACH_NO_RVALUE_DETECTION)                                                 \
sl@0:   || defined(BOOST_NO_SFINAE)                                                                   \
sl@0:   || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))                                        \
sl@0:   || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 810)                                                  \
sl@0:   || BOOST_WORKAROUND(__GNUC__, < 3)                                                            \
sl@0:   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2))                                \
sl@0:   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__))       \
sl@0:   || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))                                         \
sl@0:   || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
sl@0: #  define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION
sl@0: # else
sl@0: #  define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
sl@0: # endif
sl@0: #endif
sl@0: 
sl@0: #include <boost/mpl/if.hpp>
sl@0: #include <boost/mpl/logical.hpp>
sl@0: #include <boost/mpl/eval_if.hpp>
sl@0: #include <boost/noncopyable.hpp>
sl@0: #include <boost/range/end.hpp>
sl@0: #include <boost/range/begin.hpp>
sl@0: #include <boost/range/result_iterator.hpp>
sl@0: #include <boost/type_traits/is_array.hpp>
sl@0: #include <boost/type_traits/is_const.hpp>
sl@0: #include <boost/type_traits/is_abstract.hpp>
sl@0: #include <boost/type_traits/is_base_and_derived.hpp>
sl@0: #include <boost/iterator/iterator_traits.hpp>
sl@0: #include <boost/utility/addressof.hpp>
sl@0: 
sl@0: #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
sl@0: # include <new>
sl@0: # include <boost/aligned_storage.hpp>
sl@0: # include <boost/utility/enable_if.hpp>
sl@0: # include <boost/type_traits/remove_const.hpp>
sl@0: #endif
sl@0: 
sl@0: // This must be at global scope, hence the uglified name
sl@0: enum boost_foreach_argument_dependent_lookup_hack
sl@0: {
sl@0:     boost_foreach_argument_dependent_lookup_hack_value
sl@0: };
sl@0: 
sl@0: namespace boost
sl@0: {
sl@0: 
sl@0: // forward declarations for iterator_range
sl@0: template<typename T>
sl@0: class iterator_range;
sl@0: 
sl@0: // forward declarations for sub_range
sl@0: template<typename T>
sl@0: class sub_range;
sl@0: 
sl@0: namespace foreach
sl@0: {
sl@0:     ///////////////////////////////////////////////////////////////////////////////
sl@0:     // in_range
sl@0:     //
sl@0:     template<typename T>
sl@0:     inline std::pair<T, T> in_range(T begin, T end)
sl@0:     {
sl@0:         return std::make_pair(begin, end);
sl@0:     }
sl@0: 
sl@0:     ///////////////////////////////////////////////////////////////////////////////
sl@0:     // boost::foreach::tag
sl@0:     //
sl@0:     typedef boost_foreach_argument_dependent_lookup_hack tag;
sl@0: 
sl@0:     ///////////////////////////////////////////////////////////////////////////////
sl@0:     // boost::foreach::is_lightweight_proxy
sl@0:     //   Specialize this for user-defined collection types if they are inexpensive to copy.
sl@0:     //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.
sl@0:     template<typename T>
sl@0:     struct is_lightweight_proxy
sl@0:       : boost::mpl::false_
sl@0:     {
sl@0:     };
sl@0: 
sl@0:     ///////////////////////////////////////////////////////////////////////////////
sl@0:     // boost::foreach::is_noncopyable
sl@0:     //   Specialize this for user-defined collection types if they cannot be copied.
sl@0:     //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.
sl@0:     template<typename T>
sl@0:     struct is_noncopyable
sl@0:     #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT)
sl@0:       : boost::mpl::or_<
sl@0:             boost::is_abstract<T>
sl@0:           , boost::is_base_and_derived<boost::noncopyable, T>
sl@0:         >
sl@0:     #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED)
sl@0:       : boost::is_base_and_derived<boost::noncopyable, T>
sl@0:     #elif !defined(BOOST_NO_IS_ABSTRACT)
sl@0:       : boost::is_abstract<T>
sl@0:     #else
sl@0:       : boost::mpl::false_
sl@0:     #endif
sl@0:     {
sl@0:     };
sl@0: 
sl@0: } // namespace foreach
sl@0: 
sl@0: } // namespace boost
sl@0: 
sl@0: // vc6/7 needs help ordering the following overloads
sl@0: #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
sl@0: # define BOOST_FOREACH_TAG_DEFAULT ...
sl@0: #else
sl@0: # define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // boost_foreach_is_lightweight_proxy
sl@0: //   Another customization point for the is_lightweight_proxy optimization,
sl@0: //   this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy
sl@0: //   at the global namespace for your type.
sl@0: template<typename T>
sl@0: inline boost::foreach::is_lightweight_proxy<T> *
sl@0: boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *
sl@0: boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *
sl@0: boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *
sl@0: boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *
sl@0: boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // boost_foreach_is_noncopyable
sl@0: //   Another customization point for the is_noncopyable trait,
sl@0: //   this one works on legacy compilers. Overload boost_foreach_is_noncopyable
sl@0: //   at the global namespace for your type.
sl@0: template<typename T>
sl@0: inline boost::foreach::is_noncopyable<T> *
sl@0: boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }
sl@0: 
sl@0: namespace boost
sl@0: {
sl@0: 
sl@0: namespace foreach_detail_
sl@0: {
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // Define some utilities for assessing the properties of expressions
sl@0: //
sl@0: typedef char yes_type;
sl@0: typedef char (&no_type)[2];
sl@0: yes_type is_true(boost::mpl::true_ *);
sl@0: no_type is_true(boost::mpl::false_ *);
sl@0: 
sl@0: // Extracts the desired property from the expression without evaluating it
sl@0: #define BOOST_FOREACH_PROTECT(expr)                                                             \
sl@0:     (static_cast<boost::mpl::bool_<1 == sizeof(boost::foreach_detail_::is_true(expr))> *>(0))
sl@0: 
sl@0: template<typename Bool1, typename Bool2>
sl@0: inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }
sl@0: 
sl@0: template<typename Bool1, typename Bool2, typename Bool3>
sl@0: inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
sl@0: 
sl@0: template<typename Bool1, typename Bool2>
sl@0: inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }
sl@0: 
sl@0: template<typename Bool1, typename Bool2, typename Bool3>
sl@0: inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
sl@0: 
sl@0: template<typename Bool>
sl@0: inline boost::mpl::not_<Bool> *not_(Bool *) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::is_array<T> *is_array_(T const &) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline boost::is_const<T> *is_const_(T &) { return 0; }
sl@0: 
sl@0: #ifndef BOOST_FOREACH_NO_RVALUE_DETECTION
sl@0: template<typename T>
sl@0: inline boost::mpl::true_ *is_const_(T const &) { return 0; }
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // auto_any_t/auto_any
sl@0: //  General utility for putting an object of any type into automatic storage
sl@0: struct auto_any_base
sl@0: {
sl@0:     // auto_any_base must evaluate to false in boolean context so that
sl@0:     // they can be declared in if() statements.
sl@0:     operator bool() const
sl@0:     {
sl@0:         return false;
sl@0:     }
sl@0: };
sl@0: 
sl@0: template<typename T>
sl@0: struct auto_any : auto_any_base
sl@0: {
sl@0:     auto_any(T const &t)
sl@0:       : item(t)
sl@0:     {
sl@0:     }
sl@0: 
sl@0:     // temporaries of type auto_any will be bound to const auto_any_base
sl@0:     // references, but we still want to be able to mutate the stored
sl@0:     // data, so declare it as mutable.
sl@0:     mutable T item;
sl@0: };
sl@0: 
sl@0: typedef auto_any_base const &auto_any_t;
sl@0: 
sl@0: template<typename T, typename C>
sl@0: inline BOOST_DEDUCED_TYPENAME boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)
sl@0: {
sl@0:     return static_cast<auto_any<T> const &>(a).item;
sl@0: }
sl@0: 
sl@0: typedef boost::mpl::true_ const_;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // type2type
sl@0: //
sl@0: template<typename T, typename C = boost::mpl::false_>
sl@0: struct type2type
sl@0:   : boost::mpl::if_<C, T const, T>
sl@0: {
sl@0: };
sl@0: 
sl@0: template<typename T, typename C = boost::mpl::false_>
sl@0: struct foreach_iterator
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<
sl@0:         C
sl@0:       , range_const_iterator<T>
sl@0:       , range_iterator<T>
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: template<typename T, typename C = boost::mpl::false_>
sl@0: struct foreach_reference
sl@0:   : iterator_reference<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
sl@0: {
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // encode_type
sl@0: //
sl@0: template<typename T>
sl@0: inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }
sl@0: 
sl@0: template<typename T>
sl@0: inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // set_false
sl@0: //
sl@0: inline bool set_false(bool &b) { return b = false; }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // to_ptr
sl@0: //
sl@0: template<typename T>
sl@0: inline T *&to_ptr(T const &)
sl@0: {
sl@0:     static T *t = 0;
sl@0:     return t;
sl@0: }
sl@0: 
sl@0: // Borland needs a little extra help with arrays
sl@0: #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
sl@0: template<typename T,std::size_t N>
sl@0: inline T (*&to_ptr(T (&)[N]))[N]
sl@0: {
sl@0:     static T (*t)[N] = 0;
sl@0:     return t;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // derefof
sl@0: //
sl@0: template<typename T>
sl@0: inline T &derefof(T *t)
sl@0: {
sl@0:     // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N],
sl@0:     // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue.
sl@0:     return reinterpret_cast<T &>(
sl@0:         *const_cast<char *>(
sl@0:             reinterpret_cast<char const volatile *>(t)
sl@0:         )
sl@0:     );
sl@0: }
sl@0: 
sl@0: #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // Detect at compile-time whether an expression yields an rvalue or
sl@0: // an lvalue. This is rather non-standard, but some popular compilers
sl@0: // accept it.
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // rvalue_probe
sl@0: //
sl@0: template<typename T>
sl@0: struct rvalue_probe
sl@0: {
sl@0:     struct private_type_ {};
sl@0:     // can't ever return an array by value
sl@0:     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
sl@0:         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T
sl@0:     >::type value_type;
sl@0:     operator value_type();
sl@0:     operator T &() const;
sl@0: };
sl@0: 
sl@0: template<typename T>
sl@0: rvalue_probe<T> const make_probe(T const &t);
sl@0: 
sl@0: # define BOOST_FOREACH_IS_RVALUE(COL)                                                           \
sl@0:     boost::foreach_detail_::and_(                                                               \
sl@0:         boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL))                    \
sl@0:       , BOOST_FOREACH_PROTECT(boost::foreach_detail_::is_rvalue_(                               \
sl@0:             (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0)))
sl@0: 
sl@0: #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // Detect at run-time whether an expression yields an rvalue
sl@0: // or an lvalue. This is 100% standard C++, but not all compilers
sl@0: // accept it. Also, it causes FOREACH to break when used with non-
sl@0: // copyable collection types.
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // rvalue_probe
sl@0: //
sl@0: template<typename T>
sl@0: struct rvalue_probe
sl@0: {
sl@0:     rvalue_probe(T &t, bool &b)
sl@0:       : value(t)
sl@0:       , is_rvalue(b)
sl@0:     {
sl@0:     }
sl@0: 
sl@0:     struct private_type_ {};
sl@0:     // can't ever return an array or an abstract type by value
sl@0:     #ifdef BOOST_NO_IS_ABSTRACT
sl@0:     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
sl@0:         boost::is_array<T>, private_type_, T
sl@0:     >::type value_type;
sl@0:     #else
sl@0:     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
sl@0:         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T
sl@0:     >::type value_type;
sl@0:     #endif
sl@0:     
sl@0:     operator value_type()
sl@0:     {
sl@0:         this->is_rvalue = true;
sl@0:         return this->value;
sl@0:     }
sl@0: 
sl@0:     operator T &() const
sl@0:     {
sl@0:         return this->value;
sl@0:     }
sl@0: 
sl@0: private:
sl@0:     T &value;
sl@0:     bool &is_rvalue;
sl@0: };
sl@0: 
sl@0: template<typename T>
sl@0: rvalue_probe<T> make_probe(T &t, bool &b) { return rvalue_probe<T>(t, b); }
sl@0: 
sl@0: template<typename T>
sl@0: rvalue_probe<T const> make_probe(T const &t, bool &b)  { return rvalue_probe<T const>(t, b); }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // simple_variant
sl@0: //  holds either a T or a T const*
sl@0: template<typename T>
sl@0: struct simple_variant
sl@0: {
sl@0:     simple_variant(T const *t)
sl@0:       : is_rvalue(false)
sl@0:     {
sl@0:         *static_cast<T const **>(this->data.address()) = t;
sl@0:     }
sl@0: 
sl@0:     simple_variant(T const &t)
sl@0:       : is_rvalue(true)
sl@0:     {
sl@0:         ::new(this->data.address()) T(t);
sl@0:     }
sl@0: 
sl@0:     simple_variant(simple_variant const &that)
sl@0:       : is_rvalue(that.is_rvalue)
sl@0:     {
sl@0:         if(this->is_rvalue)
sl@0:             ::new(this->data.address()) T(*that.get());
sl@0:         else
sl@0:             *static_cast<T const **>(this->data.address()) = that.get();
sl@0:     }
sl@0: 
sl@0:     ~simple_variant()
sl@0:     {
sl@0:         if(this->is_rvalue)
sl@0:             this->get()->~T();
sl@0:     }
sl@0: 
sl@0:     T const *get() const
sl@0:     {
sl@0:         if(this->is_rvalue)
sl@0:             return static_cast<T const *>(this->data.address());
sl@0:         else
sl@0:             return *static_cast<T const * const *>(this->data.address());
sl@0:     }
sl@0: 
sl@0: private:
sl@0:     enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) };
sl@0:     simple_variant &operator =(simple_variant const &); 
sl@0:     bool const is_rvalue;
sl@0:     aligned_storage<size> data;
sl@0: };
sl@0: 
sl@0: // If the collection is an array or is noncopyable, it must be an lvalue.
sl@0: // If the collection is a lightweight proxy, treat it as an rvalue
sl@0: // BUGBUG what about a noncopyable proxy?
sl@0: template<typename LValue, typename IsProxy>
sl@0: inline BOOST_DEDUCED_TYPENAME boost::enable_if<boost::mpl::or_<LValue, IsProxy>, IsProxy>::type *
sl@0: should_copy_impl(LValue *, IsProxy *, bool *)
sl@0: {
sl@0:     return 0;
sl@0: }
sl@0: 
sl@0: // Otherwise, we must determine at runtime whether it's an lvalue or rvalue
sl@0: inline bool *
sl@0: should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)
sl@0: {
sl@0:     return is_rvalue;
sl@0: }
sl@0: 
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // contain
sl@0: //
sl@0: template<typename T>
sl@0: inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue
sl@0: {
sl@0:     return t;
sl@0: }
sl@0: 
sl@0: template<typename T>
sl@0: inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue
sl@0: {
sl@0:     // Cannot seem to get sunpro to handle addressof() with array types.
sl@0:     #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))
sl@0:     return &t;
sl@0:     #else
sl@0:     return boost::addressof(t);
sl@0:     #endif
sl@0: }
sl@0: 
sl@0: #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
sl@0: template<typename T>
sl@0: auto_any<simple_variant<T> >
sl@0: contain(T const &t, bool *rvalue)
sl@0: {
sl@0:     return *rvalue ? simple_variant<T>(t) : simple_variant<T>(&t);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////////////////
sl@0: // begin
sl@0: //
sl@0: template<typename T, typename C>
sl@0: inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
sl@0: begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
sl@0: {
sl@0:     return boost::begin(auto_any_cast<T, C>(col));
sl@0: }
sl@0: 
sl@0: template<typename T, typename C>
sl@0: inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
sl@0: begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
sl@0:     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
sl@0:     return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
sl@0: }
sl@0: 
sl@0: #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
sl@0: template<typename T>
sl@0: auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
sl@0: begin(auto_any_t col, type2type<T, const_> *, bool *)
sl@0: {
sl@0:     return boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
sl@0: }
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // end
sl@0: //
sl@0: template<typename T, typename C>
sl@0: inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
sl@0: end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
sl@0: {
sl@0:     return boost::end(auto_any_cast<T, C>(col));
sl@0: }
sl@0: 
sl@0: template<typename T, typename C>
sl@0: inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
sl@0: end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
sl@0:     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
sl@0:     return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
sl@0: }
sl@0: 
sl@0: #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
sl@0: template<typename T>
sl@0: auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
sl@0: end(auto_any_t col, type2type<T, const_> *, bool *)
sl@0: {
sl@0:     return boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
sl@0: }
sl@0: #endif
sl@0: 
sl@0: #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
sl@0: template<typename T, typename C>
sl@0: inline auto_any<int>
sl@0: end(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
sl@0: {
sl@0:     return 0; // not used
sl@0: }
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // done
sl@0: //
sl@0: template<typename T, typename C>
sl@0: inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
sl@0:     return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
sl@0: }
sl@0: 
sl@0: #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
sl@0: template<typename T, typename C>
sl@0: inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *) // null-terminated C-style strings
sl@0: {
sl@0:     return ! *auto_any_cast<T *, boost::mpl::false_>(cur);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // next
sl@0: //
sl@0: template<typename T, typename C>
sl@0: inline void next(auto_any_t cur, type2type<T, C> *)
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
sl@0:     ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
sl@0: }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // deref
sl@0: //
sl@0: template<typename T, typename C>
sl@0: inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type
sl@0: deref(auto_any_t cur, type2type<T, C> *)
sl@0: {
sl@0:     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
sl@0:     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
sl@0: }
sl@0: 
sl@0: } // namespace foreach_detail_
sl@0: } // namespace boost
sl@0: 
sl@0: // A sneaky way to get the type of the collection without evaluating the expression
sl@0: #define BOOST_FOREACH_TYPEOF(COL)                                                               \
sl@0:     (true ? 0 : boost::foreach_detail_::encode_type(COL, boost::foreach_detail_::is_const_(COL)))
sl@0: 
sl@0: // returns true_* if the type is noncopyable
sl@0: #define BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                       \
sl@0:     boost_foreach_is_noncopyable(                                                               \
sl@0:         boost::foreach_detail_::to_ptr(COL)                                                     \
sl@0:       , boost_foreach_argument_dependent_lookup_hack_value)
sl@0: 
sl@0: // returns true_* if the type is a lightweight proxy (and is not noncopyable)
sl@0: #define BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                                 \
sl@0:     boost::foreach_detail_::and_(                                                               \
sl@0:         boost::foreach_detail_::not_(BOOST_FOREACH_IS_NONCOPYABLE(COL))                         \
sl@0:       , boost_foreach_is_lightweight_proxy(                                                     \
sl@0:             boost::foreach_detail_::to_ptr(COL)                                                 \
sl@0:           , boost_foreach_argument_dependent_lookup_hack_value))
sl@0: 
sl@0: #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // R-values and const R-values supported here with zero runtime overhead
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: // No variable is needed to track the rvalue-ness of the collection expression
sl@0: # define BOOST_FOREACH_PREAMBLE()                                                               \
sl@0:     /**/
sl@0: 
sl@0: // Evaluate the collection expression
sl@0: # define BOOST_FOREACH_EVALUATE(COL)                                                            \
sl@0:     (COL)
sl@0: 
sl@0: # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \
sl@0:     (true ? 0 : boost::foreach_detail_::or_(                                                    \
sl@0:         BOOST_FOREACH_IS_RVALUE(COL)                                                            \
sl@0:       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))
sl@0: 
sl@0: #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // R-values and const R-values supported here
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: // Declare a variable to track the rvalue-ness of the collection expression
sl@0: # define BOOST_FOREACH_PREAMBLE()                                                               \
sl@0:     if (bool _foreach_is_rvalue = false) {} else
sl@0: 
sl@0: // Evaluate the collection expression, and detect if it is an lvalue or and rvalue
sl@0: # define BOOST_FOREACH_EVALUATE(COL)                                                            \
sl@0:     (true ? boost::foreach_detail_::make_probe((COL), _foreach_is_rvalue) : (COL))
sl@0: 
sl@0: // The rvalue/lvalue-ness of the collection expression is determined dynamically, unless
sl@0: // type type is an array or is noncopyable or is non-const, in which case we know it's an lvalue.
sl@0: // If the type happens to be a lightweight proxy, always make a copy.
sl@0: # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \
sl@0:     (boost::foreach_detail_::should_copy_impl(                                                  \
sl@0:         true ? 0 : boost::foreach_detail_::or_(                                                 \
sl@0:             boost::foreach_detail_::is_array_(COL)                                              \
sl@0:           , BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                   \
sl@0:           , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(COL)))               \
sl@0:       , true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                      \
sl@0:       , &_foreach_is_rvalue))
sl@0: 
sl@0: #elif !defined(BOOST_FOREACH_NO_RVALUE_DETECTION)
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // R-values supported here, const R-values NOT supported here
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: // No variable is needed to track the rvalue-ness of the collection expression
sl@0: # define BOOST_FOREACH_PREAMBLE()                                                               \
sl@0:     /**/
sl@0: 
sl@0: // Evaluate the collection expression
sl@0: # define BOOST_FOREACH_EVALUATE(COL)                                                            \
sl@0:     (COL)
sl@0: 
sl@0: // Determine whether the collection expression is an lvalue or an rvalue.
sl@0: // NOTE: this gets the answer wrong for const rvalues.
sl@0: # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \
sl@0:     (true ? 0 : boost::foreach_detail_::or_(                                                    \
sl@0:         boost::foreach_detail_::is_rvalue_((COL), 0)                                            \
sl@0:       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))
sl@0: 
sl@0: #else
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // R-values NOT supported here
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: // No variable is needed to track the rvalue-ness of the collection expression
sl@0: # define BOOST_FOREACH_PREAMBLE()                                                               \
sl@0:     /**/
sl@0: 
sl@0: // Evaluate the collection expression
sl@0: # define BOOST_FOREACH_EVALUATE(COL)                                                            \
sl@0:     (COL)
sl@0: 
sl@0: // Can't use rvalues with BOOST_FOREACH (unless they are lightweight proxies)
sl@0: # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \
sl@0:     (true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))
sl@0: 
sl@0: #endif
sl@0: 
sl@0: #define BOOST_FOREACH_CONTAIN(COL)                                                              \
sl@0:     boost::foreach_detail_::contain(                                                            \
sl@0:         BOOST_FOREACH_EVALUATE(COL)                                                             \
sl@0:       , BOOST_FOREACH_SHOULD_COPY(COL))
sl@0: 
sl@0: #define BOOST_FOREACH_BEGIN(COL)                                                                \
sl@0:     boost::foreach_detail_::begin(                                                              \
sl@0:         _foreach_col                                                                            \
sl@0:       , BOOST_FOREACH_TYPEOF(COL)                                                               \
sl@0:       , BOOST_FOREACH_SHOULD_COPY(COL))
sl@0: 
sl@0: #define BOOST_FOREACH_END(COL)                                                                  \
sl@0:     boost::foreach_detail_::end(                                                                \
sl@0:         _foreach_col                                                                            \
sl@0:       , BOOST_FOREACH_TYPEOF(COL)                                                               \
sl@0:       , BOOST_FOREACH_SHOULD_COPY(COL))
sl@0: 
sl@0: #define BOOST_FOREACH_DONE(COL)                                                                 \
sl@0:     boost::foreach_detail_::done(                                                               \
sl@0:         _foreach_cur                                                                            \
sl@0:       , _foreach_end                                                                            \
sl@0:       , BOOST_FOREACH_TYPEOF(COL))
sl@0: 
sl@0: #define BOOST_FOREACH_NEXT(COL)                                                                 \
sl@0:     boost::foreach_detail_::next(                                                               \
sl@0:         _foreach_cur                                                                            \
sl@0:       , BOOST_FOREACH_TYPEOF(COL))
sl@0: 
sl@0: #define BOOST_FOREACH_DEREF(COL)                                                                \
sl@0:     boost::foreach_detail_::deref(                                                              \
sl@0:         _foreach_cur                                                                            \
sl@0:       , BOOST_FOREACH_TYPEOF(COL))
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // BOOST_FOREACH
sl@0: //
sl@0: //   For iterating over collections. Collections can be
sl@0: //   arrays, null-terminated strings, or STL containers.
sl@0: //   The loop variable can be a value or reference. For
sl@0: //   example:
sl@0: //
sl@0: //   std::list<int> int_list(/*stuff*/);
sl@0: //   BOOST_FOREACH(int &i, int_list)
sl@0: //   {
sl@0: //       /* 
sl@0: //        * loop body goes here.
sl@0: //        * i is a reference to the int in int_list.
sl@0: //        */
sl@0: //   }
sl@0: //
sl@0: //   Alternately, you can declare the loop variable first,
sl@0: //   so you can access it after the loop finishes. Obviously,
sl@0: //   if you do it this way, then the loop variable cannot be
sl@0: //   a reference.
sl@0: //
sl@0: //   int i;
sl@0: //   BOOST_FOREACH(i, int_list)
sl@0: //       { ... }
sl@0: //
sl@0: #define BOOST_FOREACH(VAR, COL)                                                                 \
sl@0:     BOOST_FOREACH_PREAMBLE()                                                                    \
sl@0:     if (boost::foreach_detail_::auto_any_t _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \
sl@0:     if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_BEGIN(COL)) {} else     \
sl@0:     if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_END(COL)) {} else       \
sl@0:     for (bool _foreach_continue = true;                                                         \
sl@0:               _foreach_continue && !BOOST_FOREACH_DONE(COL);                                    \
sl@0:               _foreach_continue ? BOOST_FOREACH_NEXT(COL) : (void)0)                            \
sl@0:         if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \
sl@0:         for (VAR = BOOST_FOREACH_DEREF(COL); !_foreach_continue; _foreach_continue = true)
sl@0: 
sl@0: #endif