[Boost-commit] svn:boost r43508 - in trunk: boost libs/foreach/doc libs/foreach/test

From: eric_at_[hidden]
Date: 2008-03-05 01:32:41

Author: eric_niebler
Date: 2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
New Revision: 43508
URL: http://svn.boost.org/trac/boost/changeset/43508

Log:
add BOOST_REVERSE_FOREACH, fixes #1071
Added:
   trunk/libs/foreach/test/array_byref_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/array_byval_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/cstr_byref_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/cstr_byval_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/pair_byref_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/pair_byval_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/rvalue_const_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/rvalue_nonconst_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/stl_byref_r.cpp   (contents, props changed)
   trunk/libs/foreach/test/stl_byval_r.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/foreach.hpp             |   188 ++++++++++++++++++++++++++++++++++++++++
   trunk/libs/foreach/doc/foreach.qbk  |    11 ++                                      
   trunk/libs/foreach/test/Jamfile.v2  |    10 ++                                      
   trunk/libs/foreach/test/utility.hpp |    64 +++++++++++++                           
   4 files changed, 272 insertions(+), 1 deletions(-)

Modified: trunk/boost/foreach.hpp
==============================================================================
--- trunk/boost/foreach.hpp	(original)
+++ trunk/boost/foreach.hpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -69,7 +69,10 @@
 #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>
@@ -359,6 +362,37 @@
     >::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 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>
@@ -711,6 +745,114 @@
     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
 
@@ -847,6 +989,34 @@
         _foreach_cur                                                                            \
       , BOOST_FOREACH_TYPEOF(COL))
 
+#define BOOST_FOREACH_RBEGIN(COL)                                                               \
+    boost::foreach_detail_::rbegin(                                                             \
+        _foreach_col                                                                            \
+      , BOOST_FOREACH_TYPEOF(COL)                                                               \
+      , BOOST_FOREACH_SHOULD_COPY(COL))
+
+#define BOOST_FOREACH_REND(COL)                                                                 \
+    boost::foreach_detail_::rend(                                                               \
+        _foreach_col                                                                            \
+      , BOOST_FOREACH_TYPEOF(COL)                                                               \
+      , BOOST_FOREACH_SHOULD_COPY(COL))
+
+#define BOOST_FOREACH_RDONE(COL)                                                                \
+    boost::foreach_detail_::rdone(                                                              \
+        _foreach_cur                                                                            \
+      , _foreach_end                                                                            \
+      , BOOST_FOREACH_TYPEOF(COL))
+
+#define BOOST_FOREACH_RNEXT(COL)                                                                \
+    boost::foreach_detail_::rnext(                                                              \
+        _foreach_cur                                                                            \
+      , BOOST_FOREACH_TYPEOF(COL))
+
+#define BOOST_FOREACH_RDEREF(COL)                                                               \
+    boost::foreach_detail_::rderef(                                                             \
+        _foreach_cur                                                                            \
+      , BOOST_FOREACH_TYPEOF(COL))
+
 ///////////////////////////////////////////////////////////////////////////////
 // BOOST_FOREACH
 //
@@ -884,4 +1054,22 @@
         if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \
         for (VAR = BOOST_FOREACH_DEREF(COL); !_foreach_continue; _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 _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \
+    if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_RBEGIN(COL)) {} else    \
+    if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_REND(COL)) {} else      \
+    for (bool _foreach_continue = true;                                                         \
+              _foreach_continue && !BOOST_FOREACH_RDONE(COL);                                   \
+              _foreach_continue ? BOOST_FOREACH_RNEXT(COL) : (void)0)                           \
+        if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \
+        for (VAR = BOOST_FOREACH_RDEREF(COL); !_foreach_continue; _foreach_continue = true)
+
 #endif

Modified: trunk/libs/foreach/doc/foreach.qbk
==============================================================================
--- trunk/libs/foreach/doc/foreach.qbk	(original)
+++ trunk/libs/foreach/doc/foreach.qbk	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -162,6 +162,14 @@
         // Note: get_vector_float() will be called exactly once
     }    
 
+Iterate in reverse:
+
+    std::list<int> list_int( /*...*/ );
+    BOOST_REVERSE_FOREACH( int i, list_int )
+    {
+        // do something with i
+    }
+
 Iterating over rvalues doesn't work on some older compilers. Check the 
 [link foreach.portability Portability] section to see whether your
 compiler supports this.
@@ -174,7 +182,8 @@
 doesn't mean you're stuck with it, though. If you would like to use a different
 identifier (`foreach`, perhaps), you can simply do:
 
-    #define foreach BOOST_FOREACH
+    #define foreach         BOOST_FOREACH
+    #define reverse_foreach BOOST_REVERSE_FOREACH
 
 Only do this if you are sure that the identifier you choose will not cause
 name conflicts in your code.

Modified: trunk/libs/foreach/test/Jamfile.v2
==============================================================================
--- trunk/libs/foreach/test/Jamfile.v2	(original)
+++ trunk/libs/foreach/test/Jamfile.v2	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -8,16 +8,26 @@
 test-suite "foreach"
     : [ run stl_byval.cpp ]
       [ run stl_byref.cpp ]
+      [ run stl_byval_r.cpp ]
+      [ run stl_byref_r.cpp ]
       [ run array_byval.cpp ]
       [ run array_byref.cpp ]
+      [ run array_byval_r.cpp ]
+      [ run array_byref_r.cpp ]
       [ run cstr_byval.cpp ]
       [ run cstr_byref.cpp ]
+      [ run cstr_byval_r.cpp ]
+      [ run cstr_byref_r.cpp ]
       [ run pair_byval.cpp ]
       [ run pair_byref.cpp ]
+      [ run pair_byval_r.cpp ]
+      [ run pair_byref_r.cpp ]
       [ run user_defined.cpp ]
       [ run call_once.cpp ]
       [ run rvalue_const.cpp ]
       [ run rvalue_nonconst.cpp ]
+      [ run rvalue_const_r.cpp ]
+      [ run rvalue_nonconst_r.cpp ]
       [ run dependent_type.cpp ]
       [ compile noncopyable.cpp ]
     ;

Added: trunk/libs/foreach/test/array_byref_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/array_byref_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,48 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef int foreach_container_type[5];
+typedef int const foreach_const_container_type[5];
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+int my_array[5] = { 1,2,3,4,5 };
+int const (&my_const_array)[5] = my_array;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    // non-const containers by reference
+    BOOST_CHECK(sequence_equal_byref_n_r(my_array, "\5\4\3\2\1"));
+
+    // const containers by reference
+    BOOST_CHECK(sequence_equal_byref_c_r(my_const_array, "\5\4\3\2\1"));
+
+    // mutate the mutable collections
+    mutate_foreach_byref_r(my_array);
+
+    // compare the mutated collections to the actual results
+    BOOST_CHECK(sequence_equal_byref_n_r(my_array, "\6\5\4\3\2"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/array_byval_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/array_byval_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,44 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef int foreach_container_type[5];
+typedef int const foreach_const_container_type[5];
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+int my_array[5] = { 1,2,3,4,5 };
+int const (&my_const_array)[5] = my_array;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    boost::mpl::false_ *p = BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(my_array);
+
+    // non-const containers by value
+    BOOST_CHECK(sequence_equal_byval_n_r(my_array, "\5\4\3\2\1"));
+
+    // const containers by value
+    BOOST_CHECK(sequence_equal_byval_c_r(my_const_array, "\5\4\3\2\1"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/cstr_byref_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/cstr_byref_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,49 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef char *foreach_container_type;
+typedef char const *foreach_const_container_type;
+typedef char foreach_value_type;
+typedef char &foreach_reference_type;
+typedef char const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+char my_ntcs_buffer[] = "\1\2\3\4\5";
+char *my_ntcs  = my_ntcs_buffer;
+char const *my_const_ntcs  = my_ntcs;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    // non-const containers by reference
+    BOOST_CHECK(sequence_equal_byref_n_r(my_ntcs, "\5\4\3\2\1"));
+
+    // const containers by reference
+    BOOST_CHECK(sequence_equal_byref_c_r(my_const_ntcs, "\5\4\3\2\1"));
+
+    // mutate the mutable collections
+    mutate_foreach_byref_r(my_ntcs);
+
+    // compare the mutated collections to the actual results
+    BOOST_CHECK(sequence_equal_byref_n_r(my_ntcs, "\6\5\4\3\2"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/cstr_byval_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/cstr_byval_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,45 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef char *foreach_container_type;
+typedef char const *foreach_const_container_type;
+typedef char foreach_value_type;
+typedef char &foreach_reference_type;
+typedef char const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+char my_ntcs_buffer[] = "\1\2\3\4\5";
+char *my_ntcs  = my_ntcs_buffer;
+char const *my_const_ntcs  = my_ntcs;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    boost::mpl::true_ *p = BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(my_ntcs);
+
+    // non-const containers by value
+    BOOST_CHECK(sequence_equal_byval_n_r(my_ntcs, "\5\4\3\2\1"));
+
+    // const containers by value
+    BOOST_CHECK(sequence_equal_byval_c_r(my_const_ntcs, "\5\4\3\2\1"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/pair_byref_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/pair_byref_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,50 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   13 December 2004 : Initial version.
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef std::pair<int*,int*> foreach_container_type;
+typedef std::pair<int const*,int const*> const foreach_const_container_type;
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+int my_array[] = { 1,2,3,4,5 };
+std::pair<int*,int*> my_pair(my_array,my_array+5);
+std::pair<int const*,int const*> const my_const_pair(my_array,my_array+5);
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    // non-const containers by reference
+    BOOST_CHECK(sequence_equal_byref_n_r(my_pair, "\5\4\3\2\1"));
+
+    // const containers by reference
+    BOOST_CHECK(sequence_equal_byref_c_r(my_const_pair, "\5\4\3\2\1"));
+
+    // mutate the mutable collections
+    mutate_foreach_byref_r(my_pair);
+
+    // compare the mutated collections to the actual results
+    BOOST_CHECK(sequence_equal_byref_n_r(my_pair, "\6\5\4\3\2"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/pair_byval_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/pair_byval_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,45 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef std::pair<int*,int*> foreach_container_type;
+typedef std::pair<int const*,int const*> const foreach_const_container_type;
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+int my_array[] = { 1,2,3,4,5 };
+std::pair<int*,int*> my_pair(my_array,my_array+5);
+std::pair<int const*,int const*> const my_const_pair(my_array,my_array+5);
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    boost::mpl::true_ *p = BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(my_pair);
+
+    // non-const containers by value
+    BOOST_CHECK(sequence_equal_byval_n_r(my_pair, "\5\4\3\2\1"));
+
+    // const containers by value
+    BOOST_CHECK(sequence_equal_byval_c_r(my_const_pair, "\5\4\3\2\1"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/rvalue_const_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/rvalue_const_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,44 @@
+//  (C) Copyright Eric Niebler 2005.
+//  Use, modification and distribution are subject to 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)
+
+/*
+  Revision history:
+  25 August 2005 : Initial version.
+*/
+
+#include <vector>
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+#ifdef BOOST_FOREACH_NO_CONST_RVALUE_DETECTION
+// ignore error during Microsoft Code Analysis
+#if !defined(_PREFAST_)
+# error Expected failure : const rvalues disallowed
+#endif
+#else
+
+std::vector<int> const get_vector()
+{
+    return std::vector<int>(4, 4);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    int counter = 0;
+
+    BOOST_REVERSE_FOREACH(int i, get_vector())
+    {
+        counter += i;
+    }
+
+    BOOST_CHECK(16 == counter);
+
+    return 0;
+}
+
+#endif

Added: trunk/libs/foreach/test/rvalue_nonconst_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/rvalue_nonconst_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,41 @@
+//  (C) Copyright Eric Niebler 2005.
+//  Use, modification and distribution are subject to 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)
+
+/*
+  Revision history:
+  25 August 2005 : Initial version.
+*/
+
+#include <vector>
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+#ifdef BOOST_FOREACH_NO_RVALUE_DETECTION
+# error Expected failure : rvalues disallowed
+#else
+
+std::vector<int> get_vector()
+{
+    return std::vector<int>(4, 4);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    int counter = 0;
+
+    BOOST_REVERSE_FOREACH(int i, get_vector())
+    {
+        counter += i;
+    }
+
+    BOOST_CHECK(16 == counter);
+
+    return 0;
+}
+
+#endif

Added: trunk/libs/foreach/test/stl_byref_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/stl_byref_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,62 @@
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005: Initial version.
+*/
+
+#include <list>
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef std::list<int> foreach_container_type;
+typedef std::list<int> const foreach_const_container_type;
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// initialize a std::list<int>
+std::list<int> make_list()
+{
+    std::list<int> l;
+    l.push_back(1);
+    l.push_back(2);
+    l.push_back(3);
+    l.push_back(4);
+    l.push_back(5);
+    return l;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+std::list<int> my_list = make_list();
+std::list<int> const &my_const_list = my_list;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    // non-const containers by reference
+    BOOST_CHECK(sequence_equal_byref_n_r(my_list, "\5\4\3\2\1"));
+
+    // const containers by reference
+    BOOST_CHECK(sequence_equal_byref_c_r(my_const_list, "\5\4\3\2\1"));
+
+    // mutate the mutable collections
+    mutate_foreach_byref_r(my_list);
+
+    // compare the mutated collections to the actual results
+    BOOST_CHECK(sequence_equal_byref_n_r(my_list, "\6\5\4\3\2"));
+
+    return 0;
+}

Added: trunk/libs/foreach/test/stl_byval_r.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/foreach/test/stl_byval_r.cpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -0,0 +1,60 @@
+//  stl_byval.cpp
+///
+//  (C) Copyright Eric Niebler 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   25 August 2005 : Initial version.
+*/
+
+#include <list>
+#include <boost/test/minimal.hpp>
+#include <boost/foreach.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// define the container types, used by utility.hpp to generate the helper functions
+typedef std::list<int> foreach_container_type;
+typedef std::list<int> const foreach_const_container_type;
+typedef int foreach_value_type;
+typedef int &foreach_reference_type;
+typedef int const &foreach_const_reference_type;
+
+#include "./utility.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// initialize a std::list<int>
+std::list<int> make_list()
+{
+    std::list<int> l;
+    l.push_back(1);
+    l.push_back(2);
+    l.push_back(3);
+    l.push_back(4);
+    l.push_back(5);
+    return l;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// define some containers
+//
+std::list<int> my_list = make_list();
+std::list<int> const &my_const_list = my_list;
+
+///////////////////////////////////////////////////////////////////////////////
+// test_main
+//   
+int test_main( int, char*[] )
+{
+    boost::mpl::false_ *p = BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(my_list);
+
+    // non-const containers by value
+    BOOST_CHECK(sequence_equal_byval_n_r(my_list, "\5\4\3\2\1"));
+
+    // const containers by value
+    BOOST_CHECK(sequence_equal_byval_c_r(my_const_list, "\5\4\3\2\1"));
+
+    return 0;
+}

Modified: trunk/libs/foreach/test/utility.hpp
==============================================================================
--- trunk/libs/foreach/test/utility.hpp	(original)
+++ trunk/libs/foreach/test/utility.hpp	2008-03-05 01:32:39 EST (Wed, 05 Mar 2008)
@@ -76,4 +76,68 @@
     }
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+// sequence_equal_byval_n_r
+inline bool sequence_equal_byval_n_r( foreach_container_type & rng, char const * result )
+{
+    BOOST_REVERSE_FOREACH( foreach_value_type i, rng )
+    {
+        if(0 == *result || i != *result)
+            return false;
+        ++result;
+    }
+    return 0 == *result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// sequence_equal_byval_c_r
+inline bool sequence_equal_byval_c_r( foreach_const_container_type & rng, char const * result )
+{
+    BOOST_REVERSE_FOREACH( foreach_value_type i, rng )
+    {
+        if(0 == *result || i != *result)
+            return false;
+        ++result;
+    }
+    return 0 == *result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// sequence_equal_byref_n_r
+inline bool sequence_equal_byref_n_r( foreach_container_type & rng, char const * result )
+{
+    BOOST_REVERSE_FOREACH( foreach_reference_type i, rng )
+    {
+        if(0 == *result || i != *result)
+            return false;
+        ++result;
+    }
+    return 0 == *result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// sequence_equal_byref_c_r
+inline bool sequence_equal_byref_c_r( foreach_const_container_type & rng, char const * result )
+{
+    BOOST_REVERSE_FOREACH( foreach_const_reference_type i, rng )
+    {
+        if(0 == *result || i != *result)
+            return false;
+        ++result;
+    }
+    return 0 == *result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// mutate_foreach_byref
+//
+inline void mutate_foreach_byref_r( foreach_container_type & rng )
+{
+    BOOST_REVERSE_FOREACH( foreach_reference_type i, rng )
+    {
+        ++i;
+    }
+}
+
 #endif