Subject: [Boost-commit] svn:boost r62661 - trunk/boost
From: eric_at_[hidden]
Date: 2010-06-09 10:52:54
Author: eric_niebler
Date: 2010-06-09 10:52:52 EDT (Wed, 09 Jun 2010)
New Revision: 62661
URL: http://svn.boost.org/trac/boost/changeset/62661
Log:
add foreach_fwd.hpp for forward declarations of foreach's customization points, fixes #3998
Added:
trunk/boost/foreach_fwd.hpp
- copied, changed from r62660, /trunk/boost/foreach.hpp
Text files modified:
trunk/boost/foreach.hpp | 12
trunk/boost/foreach_fwd.hpp | 1063 ---------------------------------------
2 files changed, 8 insertions(+), 1067 deletions(-)
Modified: trunk/boost/foreach.hpp
==============================================================================
--- trunk/boost/foreach.hpp (original)
+++ trunk/boost/foreach.hpp 2010-06-09 10:52:52 EDT (Wed, 09 Jun 2010)
@@ -81,6 +81,7 @@
#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>
@@ -89,12 +90,6 @@
# include <boost/type_traits/remove_const.hpp>
#endif
-// This must be at global scope, hence the uglified name
-enum boost_foreach_argument_dependent_lookup_hack
-{
- boost_foreach_argument_dependent_lookup_hack_value
-};
-
namespace boost
{
@@ -118,11 +113,6 @@
}
///////////////////////////////////////////////////////////////////////////////
- // boost::foreach::tag
- //
- typedef boost_foreach_argument_dependent_lookup_hack tag;
-
- ///////////////////////////////////////////////////////////////////////////////
// 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.
Copied: trunk/boost/foreach_fwd.hpp (from r62660, /trunk/boost/foreach.hpp)
==============================================================================
--- /trunk/boost/foreach.hpp (original)
+++ trunk/boost/foreach_fwd.hpp 2010-06-09 10:52:52 EDT (Wed, 09 Jun 2010)
@@ -1,93 +1,18 @@
///////////////////////////////////////////////////////////////////////////////
// foreach.hpp header file
//
-// Copyright 2004 Eric Niebler.
+// Copyright 2010 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
+// Kazutoshi Satoda: for suggesting the need for a _fwd header for foreach's
+// customization points.
-#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)) \
- || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL))
-# 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>
-
-#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
+#ifndef BOOST_FOREACH_FWD_HPP
+#define BOOST_FOREACH_FWD_HPP
// This must be at global scope, hence the uglified name
enum boost_foreach_argument_dependent_lookup_hack
@@ -98,26 +23,9 @@
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::tag
//
typedef boost_foreach_argument_dependent_lookup_hack tag;
@@ -127,974 +35,17 @@
// 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_
- {
- };
+ struct is_lightweight_proxy;
///////////////////////////////////////////////////////////////////////////////
// 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
- {
- };
+ struct is_noncopyable;
} // 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
-{
- 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 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 &t;
- #else
- return boost::addressof(t);
- #endif
-}
-
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
-template<typename T>
-auto_any<simple_variant<T> >
-contain(T const &t, bool *rvalue)
-{
- return *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 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 iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
-}
-
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
-template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
-begin(auto_any_t col, type2type<T, const_> *, bool *)
-{
- return 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_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 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 iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
-}
-
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
-template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
-end(auto_any_t col, type2type<T, const_> *, bool *)
-{
- return 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 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 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 iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
-}
-
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
-template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
-rbegin(auto_any_t col, type2type<T, const_> *, bool *)
-{
- return 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 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 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 iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
-}
-
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
-template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
-rend(auto_any_t col, type2type<T, const_> *, bool *)
-{
- return 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 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