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