passenger 6.0.8 → 6.0.20

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

@@ -17,6 +17,7 @@
 #ifdef BOOST_MSVC
 
    #pragma warning (push)
+   #pragma warning (disable : 4619) // there is no warning number 'XXXX'
    #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
    #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
    #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter

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

@@ -47,7 +47,7 @@ struct default_header_holder : public NodeTraits::node
    { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }
 
    // (unsafe) downcast used to implement container-from-iterator
-   BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
+   BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(node_ptr p)
    { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 

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

@@ -34,7 +34,7 @@ struct empty_node_checker
 
    struct return_type {};
 
-   void operator () (const const_node_ptr&, const return_type&, const return_type&, return_type&) {}
+   void operator () (const_node_ptr, const return_type&, const return_type&, return_type&) {}
 };
 
 }  //namespace detail{

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

@@ -52,37 +52,6 @@ class exception_disposer
    }
 };
 
-template<class Container, class Disposer, class SizeType>
-class exception_array_disposer
-{
-   Container *cont_;
-   Disposer  &disp_;
-   SizeType  &constructed_;
-
-   exception_array_disposer(const exception_array_disposer&);
-   exception_array_disposer &operator=(const exception_array_disposer&);
-
-   public:
-
-   exception_array_disposer
-      (Container &cont, Disposer &disp, SizeType &constructed)
-      :  cont_(&cont), disp_(disp), constructed_(constructed)
-   {}
-
-   BOOST_INTRUSIVE_FORCEINLINE void release()
-   {  cont_ = 0;  }
-
-   ~exception_array_disposer()
-   {
-      SizeType n = constructed_;
-      if(cont_){
-         while(n--){
-            cont_[n].clear_and_dispose(disp_);
-         }
-      }
-   }
-};
-
 }  //namespace detail{
 }  //namespace intrusive{
 }  //namespace boost{

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

@@ -161,30 +161,30 @@ class generic_hook
       < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr()
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT
    {  return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
 
    public:
    /// @endcond
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook()
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& ) BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
    {  return *this;  }
 
    BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
@@ -193,20 +193,20 @@ class generic_hook
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other)
+   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes
          (this->this_ptr(), other.this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const
+   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const BOOST_NOEXCEPT
    {
       //is_linked() can be only used in safe-mode or auto-unlink
       BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
       return !node_algorithms::unique(this->this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void unlink()
+   BOOST_INTRUSIVE_FORCEINLINE void unlink() BOOST_NOEXCEPT
    {
       BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
       node_ptr n(this->this_ptr());

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

@@ -0,0 +1,92 @@
+// Copyright 2005-2014 Daniel James.
+// 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)
+//
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18.
+//
+//  This also contains public domain code from MurmurHash. From the
+//  MurmurHash header:
+//
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+//
+// Copyright 2021 Ion Gaztanaga
+// Refactored the original boost/container_hash/hash.hpp to avoid
+// any heavy std header dependencies to just combine two hash
+// values represented in a std::size_t type.
+
+#ifndef BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP
+#define BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/cstdint.hpp>
+
+#if defined(_MSC_VER)
+#  include <stdlib.h>
+#  define BOOST_INTRUSIVE_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#  define BOOST_INTRUSIVE_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template <typename SizeT>
+inline void hash_combine_size_t(SizeT& seed, SizeT value)
+{
+   seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+}
+
+inline void hash_combine_size_t(boost::uint32_t& h1, boost::uint32_t k1)
+{
+   const uint32_t c1 = 0xcc9e2d51;
+   const uint32_t c2 = 0x1b873593;
+
+   k1 *= c1;
+   k1 = BOOST_INTRUSIVE_HASH_ROTL32(k1,15);
+   k1 *= c2;
+
+   h1 ^= k1;
+   h1 = BOOST_INTRUSIVE_HASH_ROTL32(h1,13);
+   h1 = h1*5+0xe6546b64;
+}
+
+
+   // Don't define 64-bit hash combine on platforms without 64 bit integers,
+   // and also not for 32-bit gcc as it warns about the 64-bit constant.
+   #if !defined(BOOST_NO_INT64_T) && \
+       !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+   inline void hash_combine_size_t(boost::uint64_t& h, boost::uint64_t k)
+   {
+      const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+      const int r = 47;
+
+      k *= m;
+      k ^= k >> r;
+      k *= m;
+
+      h ^= k;
+      h *= m;
+
+      // Completely arbitrary number, to prevent 0's
+      // from hashing to 0.
+      h += 0xe6546b64;
+   }
+
+   #endif // BOOST_NO_INT64_T
+
+}  //namespace detail {
+}  //namespace intrusive {
+}  //namespace boost {
+
+#endif   //BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP

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

@@ -26,7 +26,10 @@
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/trivial_value_traits.hpp>
-#include <boost/intrusive/slist.hpp> //make_slist
+#include <boost/intrusive/detail/common_slist_algorithms.hpp>
+#include <boost/intrusive/detail/iiterator.hpp>
+#include <boost/intrusive/detail/slist_iterator.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <cstddef>
 #include <climits>
 #include <boost/move/core.hpp>
@@ -35,79 +38,43 @@
 namespace boost {
 namespace intrusive {
 
-template <class Slist>
-struct bucket_impl : public Slist
+template <class NodeTraits>
+struct bucket_impl
+   : public NodeTraits::node
 {
-   typedef Slist slist_type;
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
-   {}
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
-   {}
-
-   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
-   {
-      //This bucket is still being used!
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-   }
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
-   {
-      //This bucket is still in use!
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-      return *this;
-   }
-};
+   public:
+   typedef NodeTraits node_traits;
 
-template<class Slist>
-struct bucket_traits_impl
-{
    private:
-   BOOST_COPYABLE_AND_MOVABLE(bucket_traits_impl)
+   typedef typename node_traits::node_ptr          node_ptr;
+   typedef typename node_traits::const_node_ptr    const_node_ptr;
+
+   typedef detail::common_slist_algorithms<NodeTraits> algo_t;
 
    public:
-   /// @cond
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
+   {}
 
-   typedef typename pointer_traits
-      <typename Slist::pointer>::template rebind_pointer
-         < bucket_impl<Slist> >::type                                bucket_ptr;
-   typedef Slist slist;
-   typedef typename Slist::size_type size_type;
-   /// @endcond
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(bucket_ptr buckets, size_type len)
-      :  buckets_(buckets), buckets_len_(len)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(const bucket_traits_impl &x)
-      : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
+   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
-      : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
-   {  x.buckets_ = bucket_ptr();   x.buckets_len_ = 0;  }
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
+   {  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
-   {
-      buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
-      x.buckets_ = bucket_ptr();   x.buckets_len_ = 0; return *this;
-   }
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node_ptr()
+   {  return pointer_traits<node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
-   {
-      buckets_ = x.buckets_;  buckets_len_ = x.buckets_len_; return *this;
-   }
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node_ptr() const
+   {  return pointer_traits<const_node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const bucket_ptr &bucket_begin() const
-   {  return buckets_;  }
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr begin_ptr()
+   {  return node_traits::get_next(get_node_ptr());  }
+};
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type  bucket_count() const
-   {  return buckets_len_;  }
 
-   private:
-   bucket_ptr  buckets_;
-   size_type   buckets_len_;
-};
 
 template <class NodeTraits>
 struct hash_reduced_slist_node_traits
@@ -133,22 +100,7 @@ struct reduced_slist_node_traits
       >::type type;
 };
 
-template<class NodeTraits>
-struct get_slist_impl
-{
-   typedef trivial_value_traits<NodeTraits, normal_link> trivial_traits;
-
-   //Reducing symbol length
-   struct type : make_slist
-      < typename NodeTraits::node
-      , boost::intrusive::value_traits<trivial_traits>
-      , boost::intrusive::constant_time_size<false>
-      , boost::intrusive::size_type<std::size_t>
-      >::type
-   {};
-};
-
-template<class BucketValueTraits, bool IsConst>
+template<class BucketValueTraits, bool LinearBuckets, bool IsConst>
 class hashtable_iterator
 {
    typedef typename BucketValueTraits::value_traits            value_traits;
@@ -166,24 +118,25 @@ class hashtable_iterator
    private:
    typedef typename value_traits::node_traits                  node_traits;
    typedef typename node_traits::node_ptr                      node_ptr;
-   typedef typename get_slist_impl
-      < typename reduced_slist_node_traits
-         <node_traits>::type >::type                           slist_impl;
-   typedef typename slist_impl::iterator                       siterator;
-   typedef typename slist_impl::const_iterator                 const_siterator;
-   typedef bucket_impl<slist_impl>                             bucket_type;
+   typedef typename BucketValueTraits::bucket_type             bucket_type;
+   typedef typename bucket_type::node_traits                   slist_node_traits;
+   typedef typename slist_node_traits::node_ptr                slist_node_ptr;
+   typedef trivial_value_traits
+      <slist_node_traits, normal_link>                         slist_value_traits;
+   typedef slist_iterator<slist_value_traits, false>           siterator;
+   typedef slist_iterator<slist_value_traits, true>            const_siterator;
+   typedef circular_slist_algorithms<slist_node_traits>        slist_node_algorithms;
 
    typedef typename pointer_traits
       <pointer>::template rebind_pointer
          < const BucketValueTraits >::type                     const_bucketvaltraits_ptr;
-   typedef typename slist_impl::size_type                      size_type;
    class nat;
    typedef typename
       detail::if_c< IsConst
-                  , hashtable_iterator<BucketValueTraits, false>
+                  , hashtable_iterator<BucketValueTraits, LinearBuckets, false>
                   , nat>::type                                 nonconst_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -211,8 +164,8 @@ class hashtable_iterator
    BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
    { return slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, false> unconst() const
-   {  return hashtable_iterator<BucketValueTraits, false>(this->slist_it(), this->get_bucket_value_traits());   }
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const
+   {  return hashtable_iterator<BucketValueTraits, LinearBuckets, false>(this->slist_it(), this->get_bucket_value_traits());   }
 
    BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
@@ -242,43 +195,42 @@ class hashtable_iterator
          (downcast_bucket(slist_it_.pointed_node()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE const const_bucketvaltraits_ptr &get_bucket_value_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const_bucketvaltraits_ptr get_bucket_value_traits() const
    {  return traitsptr_;  }
 
    BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
    {  return traitsptr_->priv_value_traits();  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const bucket_traits &priv_bucket_traits() const
-   {  return traitsptr_->priv_bucket_traits();  }
-
    private:
+
    void increment()
    {
-      const bucket_traits &rbuck_traits = this->priv_bucket_traits();
-      bucket_type* const buckets = boost::movelib::to_raw_pointer(rbuck_traits.bucket_begin());
-      const size_type buckets_len = rbuck_traits.bucket_count();
+      bucket_type* const buckets = boost::movelib::to_raw_pointer(traitsptr_->priv_bucket_traits().bucket_begin());
+      const std::size_t buckets_len = traitsptr_->priv_bucket_traits().bucket_count();
 
       ++slist_it_;
-      const typename slist_impl::node_ptr n = slist_it_.pointed_node();
-      const siterator first_bucket_bbegin = buckets->end();
-      if(first_bucket_bbegin.pointed_node() <= n && n <= buckets[buckets_len-1].cend().pointed_node()){
+      const slist_node_ptr n = slist_it_.pointed_node();
+      const siterator first_bucket_bbegin(buckets->get_node_ptr());
+      if(first_bucket_bbegin.pointed_node() <= n && n <= buckets[buckets_len-1].get_node_ptr()){
          //If one-past the node is inside the bucket then look for the next non-empty bucket
          //1. get the bucket_impl from the iterator
-         const bucket_type &b = static_cast<const bucket_type&>
-            (bucket_type::slist_type::container_from_end_iterator(slist_it_));
+         const bucket_type &b = static_cast<const bucket_type&>(*n);
 
          //2. Now just calculate the index b has in the bucket array
-         size_type n_bucket = static_cast<size_type>(&b - buckets);
+         std::size_t n_bucket = static_cast<std::size_t>(&b - buckets);
 
          //3. Iterate until a non-empty bucket is found
+         slist_node_ptr bucket_nodeptr = buckets->get_node_ptr();
          do{
             if (++n_bucket >= buckets_len){  //bucket overflow, return end() iterator
-               slist_it_ = buckets->before_begin();
+               slist_it_ = first_bucket_bbegin;
                return;
             }
+            bucket_nodeptr = buckets[n_bucket].get_node_ptr();
          }
-         while (buckets[n_bucket].empty());
-         slist_it_ = buckets[n_bucket].begin();
+         while (slist_node_algorithms::is_empty(bucket_nodeptr));
+         slist_it_ = siterator(bucket_nodeptr);
+         ++slist_it_;
       }
       else{
          //++slist_it_ yield to a valid object
@@ -289,6 +241,134 @@ class hashtable_iterator
    const_bucketvaltraits_ptr  traitsptr_;
 };
 
+template<class BucketValueTraits, bool IsConst>
+class hashtable_iterator<BucketValueTraits, true, IsConst>
+{
+   typedef typename BucketValueTraits::value_traits            value_traits;
+   typedef typename BucketValueTraits::bucket_traits           bucket_traits;
+
+   typedef iiterator< value_traits, IsConst
+                    , std::forward_iterator_tag>   types_t;
+   public:
+   typedef typename types_t::iterator_type::difference_type    difference_type;
+   typedef typename types_t::iterator_type::value_type         value_type;
+   typedef typename types_t::iterator_type::pointer            pointer;
+   typedef typename types_t::iterator_type::reference          reference;
+   typedef typename types_t::iterator_type::iterator_category  iterator_category;
+
+   private:
+   typedef typename value_traits::node_traits                  node_traits;
+   typedef typename node_traits::node_ptr                      node_ptr;
+   typedef typename BucketValueTraits::bucket_type             bucket_type;
+   typedef typename BucketValueTraits::bucket_ptr              bucket_ptr;
+   typedef typename bucket_type::node_traits                   slist_node_traits;
+   typedef linear_slist_algorithms<slist_node_traits>          slist_node_algorithms;
+   typedef typename slist_node_traits::node_ptr                slist_node_ptr;
+   typedef trivial_value_traits
+      <slist_node_traits, normal_link>                         slist_value_traits;
+   typedef slist_iterator<slist_value_traits, false>           siterator;
+   typedef slist_iterator<slist_value_traits, true>            const_siterator;
+
+   static const bool stateful_value_traits =
+      detail::is_stateful_value_traits<value_traits>::value;
+
+   typedef typename pointer_traits
+      <pointer>::template rebind_pointer
+         < const value_traits >::type                          const_value_traits_ptr;
+   class nat;
+   typedef typename
+      detail::if_c< IsConst
+                  , hashtable_iterator<BucketValueTraits, true, false>
+                  , nat>::type                                 nonconst_iterator;
+
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(slist_node_ptr p)
+   {
+      return pointer_traits<node_ptr>::
+         pointer_to(static_cast<typename node_traits::node&>(*p));
+   }
+
+   public:
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator ()
+      : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
+      , members_()
+   {}
+
+   BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr)
+      : slist_it_ (ptr)
+      , members_ (bp, traits_ptr)
+   {}
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other)
+      :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
+   {}
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other)
+      :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
+   {}
+
+   BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
+   { return slist_it_; }
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, true, false> unconst() const
+   {  return hashtable_iterator<BucketValueTraits, true, false>(this->slist_it(), members_.nodeptr_, members_.get_ptr());   }
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
+   {  this->increment();   return *this;   }
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other)
+   {  slist_it_ = other.slist_it(); members_ = other.members_;  return *this;  }
+
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int)
+   {
+      hashtable_iterator result (*this);
+      this->increment();
+      return result;
+   }
+
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   { return i.slist_it_ == i2.slist_it_; }
+
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   { return i.slist_it_ != i2.slist_it_; }
+
+   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   { return *this->operator ->(); }
+
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
+
+   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   {  return members_.get_ptr(); }
+
+   BOOST_INTRUSIVE_FORCEINLINE bucket_ptr get_bucket_ptr() const
+   {  return members_.nodeptr_; }
+
+   private:
+
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   { return value_traits::to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
+
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   { return this->get_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
+
+   void increment()
+   {
+      ++slist_it_;
+      if (slist_it_ == siterator()){
+         slist_node_ptr bucket_nodeptr;
+         do {
+            ++members_.nodeptr_;
+             bucket_nodeptr = members_.nodeptr_->get_node_ptr();
+         }while(slist_node_algorithms::is_empty(bucket_nodeptr));
+         slist_it_ = siterator(slist_node_traits::get_next(bucket_nodeptr));
+      }
+   }
+
+   siterator   slist_it_;
+   iiterator_members<bucket_ptr, const_value_traits_ptr, stateful_value_traits> members_;
+};
+
 }  //namespace intrusive {
 }  //namespace boost {
 

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

@@ -28,6 +28,7 @@
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
+#include <boost/assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -55,7 +56,7 @@ struct bhtraits_base
    typedef node&                                                     node_reference;
    typedef const node &                                              const_node_reference;
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
    {
       pointer p = pointer_traits<pointer>::pointer_to
          (static_cast<reference>(static_cast<node_holder_reference>(*n)));
@@ -63,7 +64,7 @@ struct bhtraits_base
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
    {
       const_pointer p = pointer_traits<const_pointer>::pointer_to
          (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
@@ -132,14 +133,14 @@ struct mhtraits
          (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
             (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
@@ -174,17 +175,17 @@ struct fhtraits
    static const_node_ptr to_node_ptr(const_reference value)
    {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static pointer to_value_ptr(const node_ptr & n)
+   static pointer to_value_ptr(node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
-   static const_pointer to_value_ptr(const const_node_ptr & n)
+   static const_pointer to_value_ptr(const_node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
    private:
-   static hook_ptr to_hook_ptr(const node_ptr & n)
+   static hook_ptr to_hook_ptr(node_ptr n)
    {  return hook_ptr(&*static_cast<hook_type*>(&*n));  }
 
-   static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
+   static const_hook_ptr to_hook_ptr(const_node_ptr n)
    {  return const_hook_ptr(&*static_cast<const hook_type*>(&*n));  }
 };