passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/move/detail/meta_utils_core.hpp

@@ -114,6 +114,18 @@ struct is_same<T, T>
    static const bool value = true;
 };
 
+//////////////////////////////////////
+//        enable_if_same
+//////////////////////////////////////
+template <class T, class U, class R = void>
+struct enable_if_same : enable_if<is_same<T, U>, R> {};
+
+//////////////////////////////////////
+//        disable_if_same
+//////////////////////////////////////
+template <class T, class U, class R = void>
+struct disable_if_same : disable_if<is_same<T, U>, R> {};
+
 }  //namespace move_detail {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/move/detail/move_helpers.hpp

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2010-2012.
+// (C) Copyright Ion Gaztanaga 2010-2016.
 // 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)
@@ -20,8 +20,9 @@
 #  pragma once
 #endif
 
+#include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/move/detail/meta_utils.hpp>
+#include <boost/move/detail/type_traits.hpp>
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
@@ -43,14 +44,38 @@
 ////////////////////////////////////////
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class TYPE>
+   struct boost_move_conversion_aware_catch_1
+      : public ::boost::move_detail::enable_if_and
+                        < RETURN_VALUE
+                        , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+                        , ::boost::move_detail::is_class<TYPE>
+                        , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>
+                        >
+   {};
+
+   template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class TYPE>
+   struct boost_move_conversion_aware_catch_2
+      : public ::boost::move_detail::disable_if_or
+                        < RETURN_VALUE
+                        , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> 
+                        , ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+                        , ::boost::move_detail::and_
+                                    < ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+                                    , ::boost::move_detail::is_class<BOOST_MOVE_TEMPL_PARAM>
+                                    >
+                        >
+   {};
+
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
-      RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(TYPE &x)\
       {  return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -58,27 +83,15 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
-            typename ::boost::move_detail::enable_if_and\
-                                 < ::boost::move_detail::nat \
-                                 , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                                 , ::boost::move_detail::is_class<TYPE>\
-                                 , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>\
-                                 >::type* = 0)\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+            typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
-            typename ::boost::move_detail::disable_if_or\
-                              < ::boost::move_detail::nat \
-                              , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
-                              , ::boost::move_detail::and_ \
-                                 < ::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM> \
-                                 , ::boost::move_detail::is_class<BOOST_MOVE_TEMPL_PARAM> \
-                                 > \
-                              >::type* = 0)\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+            typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          {\
-            TYPE t(u);\
+            TYPE t((u));\
             return FWD_FUNCTION(::boost::move(t));\
          }\
       //
@@ -87,27 +100,15 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename ::boost::move_detail::enable_if_and\
-                                       < RETURN_VALUE \
-                                       , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                                       , ::boost::move_detail::is_class<TYPE>\
-                                       , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>\
-                                       >::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename ::boost::move_detail::disable_if_or\
-                           < RETURN_VALUE \
-                           , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
-                           , ::boost::move_detail::and_ \
-                              < ::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM> \
-                              , ::boost::move_detail::is_class<BOOST_MOVE_TEMPL_PARAM> \
-                              > \
-                           >::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
-            TYPE t(u);\
+            TYPE t((u));\
             return FWD_FUNCTION(::boost::move(t));\
          }\
       //
@@ -115,19 +116,19 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      typename ::boost::move_detail::enable_if_c\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c\
                         < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
                         , RETURN_VALUE >::type\
       PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
       {\
-         TYPE t(u);\
+         TYPE t((u));\
          return FWD_FUNCTION(::boost::move(t));\
       }\
    //
@@ -135,10 +136,10 @@
 #else    //BOOST_NO_CXX11_RVALUE_REFERENCES
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
-      {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      {  return FWD_FUNCTION(x); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
    //
 
@@ -151,14 +152,35 @@
 ////////////////////////////////////////
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class UNLESS_CONVERTIBLE_TO, class TYPE>
+   struct boost_move_conversion_aware_catch_1arg_1
+      : public ::boost::move_detail::enable_if_and
+                        < RETURN_VALUE
+                        , ::boost::move_detail::not_< ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> >
+                        , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+                        , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>
+                        >
+   {};
+
+   template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class UNLESS_CONVERTIBLE_TO, class TYPE>
+   struct boost_move_conversion_aware_catch_1arg_2
+      : public ::boost::move_detail::disable_if_or
+                        < RETURN_VALUE
+                        , ::boost::move_detail::is_same_or_convertible< BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO>
+                        , ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+                        , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+                        >
+   {};
+
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
       {  return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -166,24 +188,15 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
-            typename ::boost::move_detail::enable_if_and\
-                              < ::boost::move_detail::nat \
-                              , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                              , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>\
-                              >::type* = 0)\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+            typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
-            typename ::boost::move_detail::disable_if_or\
-                              < void \
-                              , ::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM>\
-                              , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                              , ::boost::move_detail::is_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO>\
-                              >::type* = 0)\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+            typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          {\
-            TYPE t(u);\
+            TYPE t((u));\
             return FWD_FUNCTION(arg1, ::boost::move(t));\
          }\
       //
@@ -192,24 +205,15 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename ::boost::move_detail::enable_if_and\
-                           < RETURN_VALUE \
-                           , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                           , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>\
-                           >::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename ::boost::move_detail::disable_if_or\
-                           < RETURN_VALUE \
-                           , ::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM>\
-                           , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>\
-                           , ::boost::move_detail::is_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO>\
-                           >::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
-            TYPE t(u);\
+            TYPE t((u));\
             return FWD_FUNCTION(arg1, ::boost::move(t));\
          }\
       //
@@ -218,21 +222,21 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      typename ::boost::move_detail::disable_if_or\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::disable_if_or\
                         < RETURN_VALUE \
                         , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
-                        , ::boost::move_detail::is_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
+                        , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
                         >::type\
       PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
       {\
-         TYPE t(u);\
+         TYPE t((u));\
          return FWD_FUNCTION(arg1, ::boost::move(t));\
       }\
    //
@@ -240,10 +244,10 @@
 #else
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
    //
 

data/src/cxx_supportlib/vendor-modified/boost/move/detail/placement_new.hpp

@@ -0,0 +1,30 @@
+#ifndef BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP
+#define BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+struct boost_move_new_t{};
+
+//avoid including <new>
+inline void *operator new(std::size_t, void *p, boost_move_new_t)
+{  return p;  }
+
+inline void operator delete(void *, void *, boost_move_new_t)
+{}
+
+#endif   //BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/detail/reverse_iterator.hpp

@@ -0,0 +1,171 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2014-2014
+//
+// 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/move for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP
+#define BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/meta_utils.hpp>
+
+namespace boost {
+namespace movelib {
+
+template<class It>
+class reverse_iterator
+{
+   public:
+   typedef typename boost::movelib::iterator_traits<It>::pointer             pointer;
+   typedef typename boost::movelib::iterator_traits<It>::reference           reference;
+   typedef typename boost::movelib::iterator_traits<It>::difference_type     difference_type;
+   typedef typename boost::movelib::iterator_traits<It>::iterator_category   iterator_category;
+   typedef typename boost::movelib::iterator_traits<It>::value_type          value_type;
+
+
+   typedef It iterator_type;
+
+   reverse_iterator()
+      : m_current()  //Value initialization to achieve "null iterators" (N3644)
+   {}
+
+   explicit reverse_iterator(It r)
+      : m_current(r)
+   {}
+
+   reverse_iterator(const reverse_iterator& r)
+      : m_current(r.base())
+   {}
+
+   template<class OtherIt>
+   reverse_iterator( const reverse_iterator<OtherIt>& r
+                   , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
+                   )
+      : m_current(r.base())
+   {}
+
+   reverse_iterator & operator=( const reverse_iterator& r)
+   {  m_current = r.base();   return *this;  }
+
+   template<class OtherIt>
+   typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+         operator=( const reverse_iterator<OtherIt>& r)
+   {  m_current = r.base();   return *this;  }
+
+   It base() const
+   {  return m_current;  }
+
+   reference operator*() const
+   {
+      It temp(m_current);
+      --temp;
+      reference r = *temp;
+      return r;
+   }
+
+   pointer operator->() const
+   {
+      It temp(m_current);
+      --temp;
+      return iterator_arrow_result(temp);
+   }
+
+   reference operator[](difference_type off) const
+   {
+      return this->m_current[-off - 1];
+   }
+
+   reverse_iterator& operator++()
+   {
+      --m_current;
+      return *this;
+   }
+
+   reverse_iterator operator++(int)
+   {
+      reverse_iterator temp((*this));
+      --m_current;
+      return temp;
+   }
+
+   reverse_iterator& operator--()
+   {
+      ++m_current;
+      return *this;
+   }
+
+   reverse_iterator operator--(int)
+   {
+      reverse_iterator temp((*this));
+      ++m_current;
+      return temp;
+   }
+
+   friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current == r.m_current;  }
+
+   friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current != r.m_current;  }
+
+   friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current > r.m_current;  }
+
+   friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current >= r.m_current;  }
+
+   friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current < r.m_current;  }
+
+   friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current <= r.m_current;  }
+
+   reverse_iterator& operator+=(difference_type off)
+   {  m_current -= off; return *this;  }
+
+   reverse_iterator& operator-=(difference_type off)
+   {  m_current += off; return *this;  }
+
+   friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+   {  return (l += off);  }
+
+   friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+   {  return (r += off);   }
+
+   friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+   {  return (l-= off);  }
+
+   friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+   {  return r.m_current - l.m_current;  }
+
+   private:
+   It m_current;   // the wrapped iterator
+};
+
+template< class Iterator >
+reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
+{
+    return reverse_iterator<Iterator>(i);
+}
+
+} //namespace movelib {
+} //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP