///////////////////////////////////////////////////////////////////////////////

// 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

//  mimomorin@...     - For a patch to use rvalue refs on supporting compilers

#ifndef BOOST_FOREACH

// MS compatible compilers support #pragma once

#if defined(_MSC_VER)

# 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 !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)                                                   \

 || defined(BOOST_MSVC) && !defined(_PREFAST_)                                 \

 || (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 5) && !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(__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) && (__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/type_traits/is_rvalue_reference.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::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

#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES

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; }

#else

template<typename T>

inline boost::is_rvalue_reference<T &&> *is_rvalue_(T &&, int) { 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") ) ...

    BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) );

    // 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") ) ...

    BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) );

    // 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::false_type*) { return 0; }

template<typename T>

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

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;

}

///////////////////////////////////////////////////////////////////////////////

// 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)

        )

    );

}

# define BOOST_FOREACH_DEREFOF(T) boost::foreach_detail_::derefof(*T)

#else

# define BOOST_FOREACH_DEREFOF(T) (*T)

#endif

#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                                  \

 && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

///////////////////////////////////////////////////////////////////////////////

// Rvalue references makes it drop-dead simple to detect at compile time

// whether an expression is an rvalue.

///////////////////////////////////////////////////////////////////////////////

# define BOOST_FOREACH_IS_RVALUE(COL)                                                           \

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

#elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                                \

 && defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

///////////////////////////////////////////////////////////////////////////////

// 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(BOOST_FOREACH_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(BOOST_FOREACH_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(BOOST_FOREACH_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(BOOST_FOREACH_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

//