Index: boost/foreach.hpp
===================================================================
--- boost/foreach.hpp	(revision 78680)
+++ boost/foreach.hpp	(working copy)
@@ -30,8 +30,22 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
+// Some compilers support rvalue references and auto type deduction.
+// With these C++11 features, temporary collections can be bound to
+// rvalue references and their lifetime is extended. No copy/move is needed.
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_AUTO_DECLARATIONS)                 \
+ && !(BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 6) && !defined(BOOST_INTEL) &&      \
+                                                                   !defined(BOOST_CLANG))        \
+ && !BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+# define BOOST_FOREACH_USE_CXX11
+// gcc 4.4-4.6 have bugs in auto type deduction. We use workaround codes
+// on these compilers.
+#elif !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_AUTO_DECLARATIONS)               \
+ && (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 6) && !defined(BOOST_INTEL) &&       \
+                                                                     !defined(BOOST_CLANG))
+# define BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND
 // Some compilers let us detect even const-qualified rvalues at compile-time
-#if !defined(BOOST_NO_RVALUE_REFERENCES)                                                         \
+#elif !defined(BOOST_NO_RVALUE_REFERENCES)                                                       \
  || BOOST_WORKAROUND(BOOST_MSVC, >= 1310) && !defined(_PREFAST_)                                 \
  || (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 5) && !defined(BOOST_INTEL) &&       \
                                                                   !defined(BOOST_CLANG))         \
@@ -88,6 +102,11 @@
 #include <boost/utility/addressof.hpp>
 #include <boost/foreach_fwd.hpp>
 
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+# include <boost/utility/enable_if.hpp>
+# include <boost/type_traits/remove_const.hpp>
+#endif
+
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 # include <new>
 # include <boost/aligned_storage.hpp>
@@ -95,6 +114,7 @@
 # include <boost/type_traits/remove_const.hpp>
 #endif
 
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 namespace boost
 {
 
@@ -153,11 +173,11 @@
 } // 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
+# 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
@@ -192,6 +212,7 @@
 template<typename T>
 inline boost::foreach::is_noncopyable<T> *
 boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }
+#endif
 
 namespace boost
 {
@@ -199,6 +220,7 @@
 namespace foreach_detail_
 {
 
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 ///////////////////////////////////////////////////////////////////////////////
 // Define some utilities for assessing the properties of expressions
 //
@@ -223,22 +245,24 @@
 template<typename T>
 inline boost::is_const<T> *is_const_(T &) { return 0; }
 
-#ifndef BOOST_FOREACH_NO_RVALUE_DETECTION
+# ifndef BOOST_FOREACH_NO_RVALUE_DETECTION
 template<typename T>
 inline boost::mpl::true_ *is_const_(T const &) { return 0; }
-#endif
+# endif
 
-#ifdef BOOST_NO_RVALUE_REFERENCES
+# ifdef BOOST_NO_RVALUE_REFERENCES
 template<typename T>
 inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }
 
 template<typename T>
 inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }
-#else
+# else
 template<typename T>
 inline boost::is_rvalue_reference<T &&> *is_rvalue_(T &&, int) { return 0; }
+# endif
 #endif
 
+#if !defined(BOOST_FOREACH_USE_CXX11)
 ///////////////////////////////////////////////////////////////////////////////
 // auto_any_t/auto_any
 //  General utility for putting an object of any type into automatic storage
@@ -268,12 +292,30 @@
 
 typedef auto_any_base const &auto_any_t;
 
+# if defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline T &auto_any_cast(auto_any_t a)
+{
+    return static_cast<auto_any<T> const &>(a).item;
+}
+# else
 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;
 }
+# endif
 
+# if defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline auto_any<T> make_auto_any(T t)
+{
+    return auto_any<T>(t);
+}
+# endif
+#endif
+
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 typedef boost::mpl::true_ const_;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -284,6 +326,7 @@
   : boost::mpl::if_<C, T const, T>
 {
 };
+#endif
 
 template<typename T>
 struct wrap_cstr
@@ -334,7 +377,7 @@
     >
 {};
 
-template<typename T, typename C = boost::mpl::false_>
+template<typename T, typename C>
 struct foreach_iterator
 {
     // **** READ THIS IF YOUR COMPILE BREAKS HERE ****
@@ -364,8 +407,16 @@
     >::type type;
 };
 
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+// just a shortcut for foreach_iterator<..., ...>
+template<typename T>
+struct foreach_iterator_
+  : foreach_iterator<typename boost::remove_const<T>::type, boost::is_const<T> >
+{
+};
+#endif
 
-template<typename T, typename C = boost::mpl::false_>
+template<typename T, typename C>
 struct foreach_reverse_iterator
 {
     // **** READ THIS IF YOUR COMPILE BREAKS HERE ****
@@ -395,12 +446,31 @@
     >::type type;
 };
 
-template<typename T, typename C = boost::mpl::false_>
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+// just a shortcut for foreach_reverse_iterator<..., ...>
+template<typename T>
+struct foreach_reverse_iterator_
+  : foreach_reverse_iterator<typename boost::remove_const<T>::type, boost::is_const<T> >
+{
+};
+#endif
+
+template<typename T, typename C>
 struct foreach_reference
   : iterator_reference<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
 {
 };
 
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+// just a shortcut for foreach_reference<..., ...>
+template<typename T>
+struct foreach_reference_
+  : foreach_reference<typename boost::remove_const<T>::type, boost::is_const<T> >
+{
+};
+#endif
+
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 ///////////////////////////////////////////////////////////////////////////////
 // encode_type
 //
@@ -430,14 +500,14 @@
 }
 
 // Borland needs a little extra help with arrays
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# 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
+# endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // derefof
@@ -454,18 +524,18 @@
     );
 }
 
-#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                                  \
- && !defined(BOOST_NO_RVALUE_REFERENCES)
+# if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                                 \
+  && !defined(BOOST_NO_RVALUE_REFERENCES)
 ///////////////////////////////////////////////////////////////////////////////
 // Rvalue references makes it drop-dead simple to detect at compile time
 // whether an expression is an rvalue.
 ///////////////////////////////////////////////////////////////////////////////
 
-# define BOOST_FOREACH_IS_RVALUE(COL)                                                           \
+#  define BOOST_FOREACH_IS_RVALUE(COL)                                                          \
     boost::foreach_detail_::is_rvalue_((COL), 0)
 
-#elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                                \
- && defined(BOOST_NO_RVALUE_REFERENCES)
+# elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)                               \
+  && defined(BOOST_NO_RVALUE_REFERENCES)
 ///////////////////////////////////////////////////////////////////////////////
 // Detect at compile-time whether an expression yields an rvalue or
 // an lvalue. This is rather non-standard, but some popular compilers
@@ -493,13 +563,13 @@
     return rvalue_probe<T>();
 }
 
-# define BOOST_FOREACH_IS_RVALUE(COL)                                                           \
+#  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)
+# 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
@@ -618,11 +688,13 @@
     return is_rvalue;
 }
 
+# endif
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // contain
 //
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 template<typename T>
 inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue
 {
@@ -640,18 +712,41 @@
     #endif
 }
 
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
+# 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
 #endif
 
 /////////////////////////////////////////////////////////////////////////////
 // begin
 //
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline typename boost::disable_if<
+    boost::is_pointer<T>
+  , typename foreach_iterator_<T>::type
+>::type
+begin(T &col)
+{
+    return boost::begin(col);
+}
+
+template<typename T>
+inline typename boost::enable_if<
+    boost::is_pointer<T>
+  , typename foreach_iterator_<T>::type
+>::type
+begin(T &col) // null-terminated C-style strings
+{
+    return col;
+}
+
+#else
 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
@@ -670,7 +765,7 @@
         iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
+# 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 *)
@@ -678,20 +773,43 @@
     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
+# endif
 
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# 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
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // end
 //
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline typename boost::disable_if<
+    boost::is_pointer<T>
+  , typename foreach_iterator_<T>::type
+>::type
+end(T &col)
+{
+    return boost::end(col);
+}
+
+template<typename T>
+inline typename boost::enable_if<
+    boost::is_pointer<T>
+  , typename foreach_iterator_<T>::type
+>::type
+end(T &col) // null-terminated C-style strings
+{
+    return 0;
+}
+
+#else
 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
@@ -710,7 +828,7 @@
         iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
+# 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 *)
@@ -718,20 +836,66 @@
     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
+# endif
 
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# 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
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // done
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline typename boost::disable_if<
+    boost::is_pointer<Col>
+  , bool
+>::type
+done(Iterator const &cur, Iterator const &end, Col &)
+{
+    return cur == end;
+}
+
+template<typename Iterator, typename Col>
+inline typename boost::enable_if<
+    boost::is_pointer<Col>
+  , bool
+>::type
+done(Iterator const &cur, Iterator const &end, Col &) // null-terminated C-style strings
+{
+    return *cur == 0;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline typename boost::disable_if<
+    boost::is_pointer<Col>
+  , bool
+>::type
+done(auto_any_t cur, auto_any_t end, Col &)
+{
+    typedef typename foreach_iterator_<Col>::type iterator;
+    return auto_any_cast<iterator>(cur) == auto_any_cast<iterator>(end);
+}
+
+template<typename Col>
+inline typename boost::enable_if<
+    boost::is_pointer<Col>
+  , bool
+>::type
+done(auto_any_t cur, auto_any_t, Col &) // null-terminated C-style strings
+{
+    typedef typename foreach_iterator_<Col>::type iterator;
+    return *auto_any_cast<iterator>(cur) == 0;
+}
+
+#else
 template<typename T, typename C>
 inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
 {
@@ -739,27 +903,63 @@
     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
+# 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
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // next
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline void next(Iterator &cur, Col &)
+{
+    ++cur;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline void next(auto_any_t cur, Col &)
+{
+    typedef typename foreach_iterator_<Col>::type iterator;
+    ++auto_any_cast<iterator>(cur);
+}
+
+#else
 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);
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // deref
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline typename foreach_reference_<Col>::type
+deref(Iterator const &cur, Col &)
+{
+    return *cur;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline typename foreach_reference_<Col>::type
+deref(auto_any_t cur, Col &)
+{
+    typedef typename foreach_iterator_<Col>::type iterator;
+    return *auto_any_cast<iterator>(cur);
+}
+
+#else
 template<typename T, typename C>
 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type
 deref(auto_any_t cur, type2type<T, C> *)
@@ -767,10 +967,37 @@
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;
     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
 }
+#endif
 
 /////////////////////////////////////////////////////////////////////////////
 // rbegin
 //
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline typename boost::disable_if<
+    boost::is_pointer<T>
+  , typename foreach_reverse_iterator_<T>::type
+>::type
+rbegin(T &col)
+{
+    return boost::rbegin(col);
+}
+
+template<typename T>
+inline typename boost::enable_if<
+    boost::is_pointer<T>
+  , typename foreach_reverse_iterator_<T>::type
+>::type
+rbegin(T &col) // null-terminated C-style strings
+{
+    typedef typename remove_const<T>::type pointer;
+    pointer p = col;
+    while(0 != *p)
+        ++p;
+    return typename foreach_reverse_iterator_<T>::type(p);
+}
+
+#else
 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
@@ -789,7 +1016,7 @@
         iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
+# 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 *)
@@ -797,9 +1024,9 @@
     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
+# endif
 
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# 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
@@ -809,11 +1036,34 @@
         ++p;
     return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p));
 }
+# endif
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // rend
 //
+#if defined(BOOST_FOREACH_USE_CXX11) || defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename T>
+inline typename boost::disable_if<
+    boost::is_pointer<T>
+  , typename foreach_reverse_iterator_<T>::type
+>::type
+rend(T &col)
+{
+    return boost::rend(col);
+}
+
+template<typename T>
+inline typename boost::enable_if<
+    boost::is_pointer<T>
+  , typename foreach_reverse_iterator_<T>::type
+>::type
+rend(T &col) // null-terminated C-style strings
+{
+    return typename foreach_reverse_iterator_<T>::type(col);
+}
+
+#else
 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
@@ -832,7 +1082,7 @@
         iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
-#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
+# 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 *)
@@ -840,9 +1090,9 @@
     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
+# endif
 
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# 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
@@ -850,31 +1100,84 @@
     return auto_any<reverse_iterator<T *> >(
         reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col)));
 }
+# endif
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // rdone
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline bool rdone(Iterator const &cur, Iterator const &end, Col &)
+{
+    return cur == end;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline bool rdone(auto_any_t cur, auto_any_t end, Col &)
+{
+    typedef typename foreach_reverse_iterator_<Col>::type iterator;
+    return auto_any_cast<iterator>(cur) == auto_any_cast<iterator>(end);
+}
+
+#else
 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);
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // rnext
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline void rnext(Iterator &cur, Col &)
+{
+    ++cur;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline void rnext(auto_any_t cur, Col &)
+{
+    typedef typename foreach_reverse_iterator_<Col>::type iterator;
+    ++auto_any_cast<iterator>(cur);
+}
+
+#else
 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);
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // rderef
 //
+#if defined(BOOST_FOREACH_USE_CXX11)
+template<typename Iterator, typename Col>
+inline typename foreach_reference_<Col>::type
+rderef(Iterator const &cur, Col &)
+{
+    return *cur;
+}
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+template<typename Col>
+inline typename foreach_reference_<Col>::type
+rderef(auto_any_t cur, Col &)
+{
+    typedef typename foreach_reverse_iterator_<Col>::type iterator;
+    return *auto_any_cast<iterator>(cur);
+}
+
+#else
 template<typename T, typename C>
 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type
 rderef(auto_any_t cur, type2type<T, C> *)
@@ -882,6 +1185,7 @@
     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t;
     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
 }
+#endif
 
 } // namespace foreach_detail_
 } // namespace boost
@@ -904,26 +1208,93 @@
 # define BOOST_FOREACH_ID(x) BOOST_PP_CAT(x, __LINE__)
 #endif
 
+#if !defined(BOOST_FOREACH_USE_CXX11) && !defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
 // A sneaky way to get the type of the collection without evaluating the expression
-#define BOOST_FOREACH_TYPEOF(COL)                                                               \
+# 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)                                                       \
+# 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)                                                 \
+# 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))
+#endif
 
-#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)
+#if defined(BOOST_FOREACH_USE_CXX11)
 ///////////////////////////////////////////////////////////////////////////////
+// R-values and const R-values are bound to rvalue references
+///////////////////////////////////////////////////////////////////////////////
+
+// No variable is needed to track the rvalue-ness of the collection expression
+# define BOOST_FOREACH_PREAMBLE()                                                               \
+    BOOST_FOREACH_SUPPRESS_WARNINGS()
+
+namespace boost { namespace foreach_detail_
+{
+    template<typename T>
+    inline boost::is_rvalue_reference<T &&> *is_rvalue(T &&) { return 0; }
+
+    template<typename T, typename Cond>
+    inline typename boost::mpl::if_<Cond, T const &, T &>::type
+    add_const_if(T &t, Cond *)
+    {
+        return t;
+    }
+}}
+
+# define BOOST_FOREACH_IS_RVALUE(COL) (true ? 0 : boost::foreach_detail_::is_rvalue(COL))
+
+// Non-const rvalue collections are accessed as const references.
+# define BOOST_FOREACH_REF(COL)                                                                 \
+    boost::foreach_detail_::add_const_if(                                                       \
+        BOOST_FOREACH_ID(_foreach_col)                                                          \
+      , BOOST_FOREACH_IS_RVALUE(COL))
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+///////////////////////////////////////////////////////////////////////////////
+// R-values and const R-values are bound to const lvalue references
+///////////////////////////////////////////////////////////////////////////////
+
+// No variable is needed to track the rvalue-ness of the collection expression
+# define BOOST_FOREACH_PREAMBLE()                                                               \
+    BOOST_FOREACH_SUPPRESS_WARNINGS()
+
+namespace boost { namespace foreach_detail_
+{
+    template<typename T>
+    inline boost::mpl::true_  *is_nonconst_lvalue(T&)       { return 0; }
+
+    template<typename T>
+    inline boost::mpl::false_ *is_nonconst_lvalue(T const&) { return 0; }
+
+    template<typename T, typename Cond>
+    inline typename boost::mpl::if_<Cond, typename boost::remove_const<T>::type &, T &>::type
+    remove_const_if(T &t, Cond *)
+    {
+        return const_cast<
+            typename boost::mpl::if_<Cond, typename boost::remove_const<T>::type &, T &>::type
+        >(t);
+    }
+}}
+
+# define BOOST_FOREACH_IS_NONCONST_LVALUE(COL) (true ? 0 : boost::foreach_detail_::is_nonconst_lvalue(COL))
+
+// Only non-const lvalue collections are accessed as non-const references.
+# define BOOST_FOREACH_REF(COL)                                                                 \
+    boost::foreach_detail_::remove_const_if(                                                    \
+        BOOST_FOREACH_ID(_foreach_col)                                                          \
+      , BOOST_FOREACH_IS_NONCONST_LVALUE(COL))
+
+#elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION)
+///////////////////////////////////////////////////////////////////////////////
 // R-values and const R-values supported here with zero runtime overhead
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1005,67 +1376,172 @@
 
 #endif
 
-#define BOOST_FOREACH_CONTAIN(COL)                                                              \
+#if defined(BOOST_FOREACH_USE_CXX11)
+# define BOOST_FOREACH_BEGIN(COL)                                                               \
+    boost::foreach_detail_::begin(                                                              \
+        BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_END(COL)                                                                 \
+    boost::foreach_detail_::end(                                                                \
+        BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_DONE(COL)                                                                \
+    boost::foreach_detail_::done(                                                               \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_ID(_foreach_end)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_NEXT(COL)                                                                \
+    boost::foreach_detail_::next(                                                               \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_DEREF(COL)                                                               \
+    boost::foreach_detail_::deref(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RBEGIN(COL)                                                              \
+    boost::foreach_detail_::rbegin(                                                             \
+        BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_REND(COL)                                                                \
+    boost::foreach_detail_::rend(                                                               \
+        BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RDONE(COL)                                                               \
+    boost::foreach_detail_::rdone(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_ID(_foreach_end)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RNEXT(COL)                                                               \
+    boost::foreach_detail_::rnext(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RDEREF(COL)                                                              \
+    boost::foreach_detail_::rderef(                                                             \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+# define BOOST_FOREACH_BEGIN(COL)                                                               \
+    boost::foreach_detail_::make_auto_any(                                                      \
+        boost::foreach_detail_::begin(                                                          \
+            BOOST_FOREACH_REF(COL)))
+
+# define BOOST_FOREACH_END(COL)                                                                 \
+    boost::foreach_detail_::make_auto_any(                                                      \
+        boost::foreach_detail_::end(                                                            \
+            BOOST_FOREACH_REF(COL)))
+
+# define BOOST_FOREACH_DONE(COL)                                                                \
+    boost::foreach_detail_::done(                                                               \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_ID(_foreach_end)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_NEXT(COL)                                                                \
+    boost::foreach_detail_::next(                                                               \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_DEREF(COL)                                                               \
+    boost::foreach_detail_::deref(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RBEGIN(COL)                                                              \
+    boost::foreach_detail_::make_auto_any(                                                      \
+        boost::foreach_detail_::rbegin(                                                         \
+            BOOST_FOREACH_REF(COL)))
+
+# define BOOST_FOREACH_REND(COL)                                                                \
+    boost::foreach_detail_::make_auto_any(                                                      \
+        boost::foreach_detail_::rend(                                                           \
+            BOOST_FOREACH_REF(COL)))
+
+# define BOOST_FOREACH_RDONE(COL)                                                               \
+    boost::foreach_detail_::rdone(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_ID(_foreach_end)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RNEXT(COL)                                                               \
+    boost::foreach_detail_::rnext(                                                              \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+# define BOOST_FOREACH_RDEREF(COL)                                                              \
+    boost::foreach_detail_::rderef(                                                             \
+        BOOST_FOREACH_ID(_foreach_cur)                                                          \
+      , BOOST_FOREACH_REF(COL))
+
+#else
+# define BOOST_FOREACH_CONTAIN(COL)                                                             \
     boost::foreach_detail_::contain(                                                            \
         BOOST_FOREACH_EVALUATE(COL)                                                             \
       , BOOST_FOREACH_SHOULD_COPY(COL))
 
-#define BOOST_FOREACH_BEGIN(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)                                                                  \
+# 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)                                                                 \
+# 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)                                                                 \
+# define BOOST_FOREACH_NEXT(COL)                                                                \
     boost::foreach_detail_::next(                                                               \
         BOOST_FOREACH_ID(_foreach_cur)                                                          \
       , BOOST_FOREACH_TYPEOF(COL))
 
-#define BOOST_FOREACH_DEREF(COL)                                                                \
+# define BOOST_FOREACH_DEREF(COL)                                                               \
     boost::foreach_detail_::deref(                                                              \
         BOOST_FOREACH_ID(_foreach_cur)                                                          \
       , BOOST_FOREACH_TYPEOF(COL))
 
-#define BOOST_FOREACH_RBEGIN(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)                                                                 \
+# 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)                                                                \
+# 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)                                                                \
+# define BOOST_FOREACH_RNEXT(COL)                                                               \
     boost::foreach_detail_::rnext(                                                              \
         BOOST_FOREACH_ID(_foreach_cur)                                                          \
       , BOOST_FOREACH_TYPEOF(COL))
 
-#define BOOST_FOREACH_RDEREF(COL)                                                               \
+# define BOOST_FOREACH_RDEREF(COL)                                                              \
     boost::foreach_detail_::rderef(                                                             \
         BOOST_FOREACH_ID(_foreach_cur)                                                          \
       , BOOST_FOREACH_TYPEOF(COL))
 
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // BOOST_FOREACH
 //
@@ -1092,8 +1568,41 @@
 //   BOOST_FOREACH(i, int_list)
 //       { ... }
 //
-#define BOOST_FOREACH(VAR, COL)                                                                                   \
+#if defined(BOOST_FOREACH_USE_CXX11)
+# define BOOST_FOREACH(VAR, COL)                                                                                  \
     BOOST_FOREACH_PREAMBLE()                                                                                      \
+    if (bool BOOST_FOREACH_ID(_foreach_col_defined) = false) {} else                                              \
+    for (auto &&BOOST_FOREACH_ID(_foreach_col) = (COL);                                                           \
+        !BOOST_FOREACH_ID(_foreach_col_defined); BOOST_FOREACH_ID(_foreach_col_defined) = true)                   \
+    if (bool BOOST_FOREACH_ID(_foreach_cur_defined) = false) {} else                                              \
+    for (auto BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_BEGIN(COL);                                          \
+        !BOOST_FOREACH_ID(_foreach_cur_defined); BOOST_FOREACH_ID(_foreach_cur_defined) = true)                   \
+    if (bool BOOST_FOREACH_ID(_foreach_end_defined) = false) {} else                                              \
+    for (auto BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_END(COL);                                            \
+        !BOOST_FOREACH_ID(_foreach_end_defined); BOOST_FOREACH_ID(_foreach_end_defined) = true)                   \
+    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_ID(_foreach_continue) = false) ) {} else                                              \
+        for (VAR = BOOST_FOREACH_DEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true)
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+# define BOOST_FOREACH(VAR, COL)                                                                                  \
+    BOOST_FOREACH_PREAMBLE()                                                                                      \
+    if (bool BOOST_FOREACH_ID(_foreach_col_defined) = false) {} else                                              \
+    for (auto const &BOOST_FOREACH_ID(_foreach_col) = (COL);                                                      \
+        !BOOST_FOREACH_ID(_foreach_col_defined); BOOST_FOREACH_ID(_foreach_col_defined) = true)                   \
+    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_ID(_foreach_continue) = false) ) {} else                                              \
+        for (VAR = BOOST_FOREACH_DEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true)
+
+#else
+# 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       \
@@ -1103,6 +1612,8 @@
         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)
 
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // BOOST_REVERSE_FOREACH
 //
@@ -1110,8 +1621,44 @@
 //   all other respects, BOOST_REVERSE_FOREACH is like
 //   BOOST_FOREACH.
 //
-#define BOOST_REVERSE_FOREACH(VAR, COL)                                                                           \
+#if defined(BOOST_FOREACH_USE_CXX11)
+# define BOOST_REVERSE_FOREACH(VAR, COL)                                                                          \
     BOOST_FOREACH_PREAMBLE()                                                                                      \
+    if (bool BOOST_FOREACH_ID(_foreach_col_defined) = false) {} else                                              \
+    for (auto &&BOOST_FOREACH_ID(_foreach_col) = (COL);                                                           \
+        !BOOST_FOREACH_ID(_foreach_col_defined); BOOST_FOREACH_ID(_foreach_col_defined) = true)                   \
+                                                                                                                  \
+    if (bool BOOST_FOREACH_ID(_foreach_cur_defined) = false) {} else                                              \
+    for (auto BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_RBEGIN(COL);                                         \
+        !BOOST_FOREACH_ID(_foreach_cur_defined); BOOST_FOREACH_ID(_foreach_cur_defined) = true)                   \
+                                                                                                                  \
+    if (bool BOOST_FOREACH_ID(_foreach_end_defined) = false) {} else                                              \
+    for (auto BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_REND(COL);                                           \
+        !BOOST_FOREACH_ID(_foreach_end_defined); BOOST_FOREACH_ID(_foreach_end_defined) = true)                   \
+                                                                                                                  \
+    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_ID(_foreach_continue) = false) ) {} else                                              \
+        for (VAR = BOOST_FOREACH_RDEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true)
+
+#elif defined(BOOST_FOREACH_USE_CXX11_GCC_WORKAROUND)
+# define BOOST_REVERSE_FOREACH(VAR, COL)                                                                          \
+    BOOST_FOREACH_PREAMBLE()                                                                                      \
+    if (bool BOOST_FOREACH_ID(_foreach_col_defined) = false) {} else                                              \
+    for (auto const &BOOST_FOREACH_ID(_foreach_col) = (COL);                                                      \
+        !BOOST_FOREACH_ID(_foreach_col_defined); BOOST_FOREACH_ID(_foreach_col_defined) = true)                   \
+    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_ID(_foreach_continue) = false) ) {} else                                              \
+        for (VAR = BOOST_FOREACH_RDEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true)
+
+#else
+# 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      \
@@ -1122,3 +1669,5 @@
         for (VAR = BOOST_FOREACH_RDEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true)
 
 #endif
+
+#endif