passenger 6.0.14 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/iterator.hpp

@@ -49,6 +49,11 @@ namespace boost {
 namespace intrusive {
 
 using boost::movelib::iterator_traits;
+using boost::movelib::iter_difference;
+using boost::movelib::iter_value;
+using boost::movelib::iter_category;
+using boost::movelib::iter_size;
+
 
 ////////////////////
 //    iterator
@@ -63,26 +68,59 @@ struct iterator
    typedef Reference    reference;
 };
 
-////////////////////////////////////////
-//    iterator_[dis|en]able_if_boost_iterator
-////////////////////////////////////////
-template<class I>
-struct is_boost_iterator
+////////////////////////////////////////////////////////////////////////////////
+//    Conversion from boost::iterator traversals to std tags
+////////////////////////////////////////////////////////////////////////////////
+
+template<class Tag>
+struct get_std_category_from_tag
 {
-   static const bool value = false;
+   typedef Tag type;
 };
 
-template<class Category, class Traversal>
-struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::incrementable_traversal_tag> >
 {
-   static const bool value = true;
+   typedef std::input_iterator_tag type;
 };
 
-template<class I, class R = void>
-struct iterator_enable_if_boost_iterator
-   : ::boost::move_detail::enable_if_c
-      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
-      , R>
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::single_pass_traversal_tag> >
+{
+   typedef std::input_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::forward_traversal_tag> >
+{
+   typedef std::input_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::bidirectional_traversal_tag> >
+{
+   typedef std::bidirectional_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::random_access_traversal_tag> >
+{
+   typedef std::random_access_iterator_tag type;
+};
+
+template<class It>
+struct get_std_category_from_it
+   : get_std_category_from_tag< typename boost::intrusive::iter_category<It>::type >
 {};
 
 ////////////////////////////////////////
@@ -92,7 +130,7 @@ template<class I, class Tag, class R = void>
 struct iterator_enable_if_tag
    : ::boost::move_detail::enable_if_c
       < ::boost::move_detail::is_same
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value
          , R>
@@ -102,7 +140,7 @@ template<class I, class Tag, class R = void>
 struct iterator_disable_if_tag
    : ::boost::move_detail::enable_if_c
       < !::boost::move_detail::is_same
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value
          , R>
@@ -115,11 +153,11 @@ template<class I, class Tag, class Tag2, class R = void>
 struct iterator_enable_if_convertible_tag
    : ::boost::move_detail::enable_if_c
       < ::boost::move_detail::is_same_or_convertible
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value &&
         !::boost::move_detail::is_same_or_convertible
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag2
          >::value
          , R>
@@ -130,37 +168,37 @@ struct iterator_enable_if_convertible_tag
 ////////////////////////////////////////
 template<class I, class Tag>
 struct iterator_enable_if_tag_difference_type
-   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
 {};
 
 template<class I, class Tag>
 struct iterator_disable_if_tag_difference_type
-   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
 {};
 
 ////////////////////
 //    advance
 ////////////////////
 
-template<class InputIt, class Distance>
+template<class InputIt>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
       ++it;
 }
 
-template<class InputIt, class Distance>
+template<class InputIt>
 typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
       ++it;
 }
 
-template<class InputIt, class Distance>
+template<class InputIt>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    for (; 0 < n; --n)
       ++it;
@@ -175,63 +213,22 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
    it += n;
 }
 
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
+template<class It>
+BOOST_INTRUSIVE_FORCEINLINE 
+   void iterator_uadvance(It& it, typename iter_size<It>::type n)
 {
-   while(n--)
-      ++it;
+   (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
 }
 
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   while(n--)
-      ++it;
-}
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   while(n--)
-      ++it;
-}
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   for (; 0 < n; --n)
-      ++it;
-   for (; n < 0; ++n)
-      --it;
-}
-
-class fake{};
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   it += n;
-}
-
-////////////////////
-//    distance
-////////////////////
+////////////////////////////////////////
+//    iterator_distance
+////////////////////////////////////////
 template<class InputIt> inline
 typename iterator_disable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
-   typename iterator_traits<InputIt>::difference_type off = 0;
+   typename iter_difference<InputIt>::type off = 0;
    while(first != last){
       ++off;
       ++first;
@@ -244,10 +241,43 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
-   typename iterator_traits<InputIt>::difference_type off = last - first;
+   typename iter_difference<InputIt>::type off = last - first;
    return off;
 }
 
+////////////////////////////////////////
+//    iterator_udistance
+////////////////////////////////////////
+
+template<class It>
+BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
+   iterator_udistance(It first, It last)
+{
+   return (typename iter_size<It>::type)(iterator_distance)(first, last);
+}
+
+////////////////////////////////////////
+//    iterator_next
+////////////////////////////////////////
+
+template<class InputIt>
+BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
+{
+   (iterator_advance)(it, n);
+   return it;
+}
+
+template<class InputIt>
+BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
+{
+   (iterator_uadvance)(it, n);
+   return it;
+}
+
+////////////////////////////////////////
+// iterator_arrow_result
+////////////////////////////////////////
+
 template<class I>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/list_iterator.hpp

@@ -63,7 +63,7 @@ class list_iterator
    BOOST_INTRUSIVE_FORCEINLINE list_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
+   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
@@ -81,8 +81,8 @@ class list_iterator
    BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const node_ptr &node)
-   {  members_.nodeptr_ = node;  return *this;  }
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(node_ptr nodeptr)
+   {  members_.nodeptr_ = nodeptr;  return *this;  }
 
    BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/list_node.hpp

@@ -47,19 +47,19 @@ struct list_node_traits
    typedef typename node::node_ptr     node_ptr;
    typedef typename pointer_rebind<VoidPointer, const node>::type   const_node_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const_node_ptr n)
    {  return n->prev_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(node_ptr n)
    {  return n->prev_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_previous(node_ptr n, node_ptr prev)
    {  n->prev_ = prev;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const_node_ptr n)
    {  return n->next_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(node_ptr n)
    {  return n->next_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/math.hpp

@@ -93,7 +93,7 @@ namespace detail {
    struct builtin_clz_dispatch< ::boost::ulong_long_type >
    {
       static ::boost::ulong_long_type call(::boost::ulong_long_type n)
-      {  return __builtin_clzll(n); }
+      {  return (::boost::ulong_long_type)__builtin_clzll(n); }
    };
    #endif
 
@@ -101,14 +101,14 @@ namespace detail {
    struct builtin_clz_dispatch<unsigned long>
    {
       static unsigned long call(unsigned long n)
-      {  return __builtin_clzl(n); }
+      {  return (unsigned long)__builtin_clzl(n); }
    };
 
    template<>
    struct builtin_clz_dispatch<unsigned int>
    {
       static unsigned int call(unsigned int n)
-      {  return __builtin_clz(n); }
+      {  return (unsigned int)__builtin_clz(n); }
    };
 
    inline std::size_t floor_log2(std::size_t n)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/mpl.hpp

@@ -155,7 +155,7 @@ template <class T>\
 struct TRAITS_PREFIX##_bool\
 {\
    template<bool Add>\
-   struct two_or_three {yes_type _[2 + Add];};\
+   struct two_or_three {yes_type _[2u + (unsigned)Add];};\
    template <class U> static yes_type test(...);\
    template <class U> static two_or_three<U::TYPEDEF_TO_FIND> test (int);\
    static const std::size_t value = sizeof(test<T>(0));\

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/node_cloner_disposer.hpp

@@ -59,7 +59,7 @@ struct node_cloner
    {}
 
    // tree-based containers use this method, which is proxy-reference friendly
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p)
    {
       reference_type v = *traits_->to_value_ptr(p);
       node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
@@ -85,11 +85,11 @@ struct node_disposer
    static const bool safemode_or_autounlink =
       is_safe_autounlink<value_traits::link_mode>::value;
 
-   node_disposer(F f, const ValueTraits *cont)
+   BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont)
       :  base_t(f), traits_(cont)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
    {
       BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(p);

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/node_to_value.hpp

@@ -103,7 +103,7 @@ struct node_to_value
    typedef typename pointer_traits<npointer>::
       template rebind_pointer<const ValueTraits>::type const_value_traits_ptr;
 
-   node_to_value(const const_value_traits_ptr &ptr)
+   node_to_value(const_value_traits_ptr ptr)
       :  Base(ptr)
    {}
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/rbtree_node.hpp

@@ -74,40 +74,40 @@ struct default_rbtree_node_traits_impl
 
    typedef typename node::color color;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const_node_ptr n)
    {  return n->parent_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(node_ptr n)
    {  return n->parent_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->parent_ = p;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const_node_ptr n)
    {  return n->left_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(node_ptr n)
    {  return n->left_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->left_ = l;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const_node_ptr n)
    {  return n->right_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(node_ptr n)
    {  return n->right_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const_node_ptr n)
    {  return n->color_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(node_ptr n)
    {  return n->color_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_color(const node_ptr & n, color c)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_color(node_ptr n, color c)
    {  n->color_ = c;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static color black()
@@ -130,40 +130,40 @@ struct compact_rbtree_node_traits_impl
 
    typedef typename node::color color;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const_node_ptr n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(node_ptr n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  ptr_bit::set_pointer(n->parent_, p);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const_node_ptr n)
    {  return n->left_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(node_ptr n)
    {  return n->left_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->left_ = l;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const_node_ptr n)
    {  return n->right_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(node_ptr n)
    {  return n->right_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const_node_ptr n)
    {  return (color)ptr_bit::get_bits(n->parent_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(node_ptr n)
    {  return (color)ptr_bit::get_bits(n->parent_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_color(const node_ptr & n, color c)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_color(node_ptr n, color c)
    {  ptr_bit::set_bits(n->parent_, c != 0);  }
 
    BOOST_INTRUSIVE_FORCEINLINE static color black()

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

@@ -13,153 +13,16 @@
 #ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
 #define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
 
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/intrusive/detail/iterator.hpp>
-#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/move/detail/reverse_iterator.hpp>
 
 namespace boost {
 namespace intrusive {
 
-template<class It>
-class reverse_iterator
-{
-   public:
-   typedef typename boost::intrusive::iterator_traits<It>::pointer             pointer;
-   typedef typename boost::intrusive::iterator_traits<It>::reference           reference;
-   typedef typename boost::intrusive::iterator_traits<It>::difference_type     difference_type;
-   typedef typename boost::intrusive::iterator_traits<It>::iterator_category   iterator_category;
-   typedef typename boost::intrusive::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::intrusive::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::intrusive::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
-};
+using boost::movelib::reverse_iterator;
+using boost::movelib::make_reverse_iterator;
 
 } //namespace intrusive {
 } //namespace boost {
 
-#include <boost/intrusive/detail/config_end.hpp>
 
 #endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/simple_disposers.hpp

@@ -41,7 +41,7 @@ class init_disposer
    typedef typename NodeAlgorithms::node_ptr node_ptr;
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
    {  NodeAlgorithms::init(p);   }
 };