passenger 6.0.14 → 6.0.15

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

@@ -49,13 +49,13 @@ struct any_list_node_traits
    typedef typename node::node_ptr        node_ptr;
    typedef typename node::const_node_ptr  const_node_ptr;
 
-   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->node_ptr_1;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
    {  n->node_ptr_1 = next;  }
 
-   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->node_ptr_2;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_previous(node_ptr n, node_ptr prev)
@@ -70,7 +70,7 @@ struct any_slist_node_traits
    typedef typename node::node_ptr        node_ptr;
    typedef typename node::const_node_ptr  const_node_ptr;
 
-   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->node_ptr_1;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
@@ -90,22 +90,22 @@ struct any_unordered_node_traits
    static const bool store_hash        = true;
    static const bool optimize_multikey = true;
 
-   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->node_ptr_1;   }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
    {  n->node_ptr_1 = next;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_prev_in_group(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_prev_in_group(const_node_ptr n)
    {  return n->node_ptr_2;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_prev_in_group(node_ptr n, node_ptr prev)
    {  n->node_ptr_2 = prev;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_hash(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_hash(const_node_ptr n)
    {  return n->size_t_1;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_hash(const node_ptr & n, std::size_t h)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_hash(node_ptr n, std::size_t h)
    {  n->size_t_1 = h;  }
 };
 
@@ -119,28 +119,28 @@ struct any_rbtree_node_traits
 
    typedef std::size_t 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->node_ptr_1;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->node_ptr_1 = 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->node_ptr_2;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->node_ptr_2 = 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->node_ptr_3;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->node_ptr_3 = 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->size_t_1;  }
 
-   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->size_t_1 = c;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static color black()
@@ -160,28 +160,28 @@ struct any_avltree_node_traits
 
    typedef std::size_t balance;
 
-   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->node_ptr_1;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->node_ptr_1 = 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->node_ptr_2;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->node_ptr_2 = 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->node_ptr_3;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->node_ptr_3 = r;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const_node_ptr n)
    {  return n->size_t_1;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(const node_ptr & n, balance b)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(node_ptr n, balance b)
    {  n->size_t_1 = b;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static balance negative()
@@ -202,19 +202,19 @@ struct any_tree_node_traits
    typedef typename node::node_ptr        node_ptr;
    typedef typename node::const_node_ptr  const_node_ptr;
 
-   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->node_ptr_1;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->node_ptr_1 = 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->node_ptr_2;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->node_ptr_2 = 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->node_ptr_3;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
@@ -252,7 +252,7 @@ class any_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr & node) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr node) BOOST_NOEXCEPT
    {  node->node_ptr_1 = node_ptr();   };
 
    //! <b>Effects</b>: Returns true if node is in the same state as if called init(node)
@@ -260,19 +260,19 @@ class any_algorithms
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & node)
+   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr node)
    {  return !node->node_ptr_1;  };
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & node) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr node) BOOST_NOEXCEPT
    {  return !node->node_ptr_1; }
 
-   static void unlink(const node_ptr &)
+   static void unlink(node_ptr)
    {
       //Auto-unlink hooks and unlink() are not available for any hooks
       any_algorithms<VoidPointer>::template function_not_available_for_any_hooks<node_ptr>();
    }
 
-   static void swap_nodes(const node_ptr &, const node_ptr &)
+   static void swap_nodes(node_ptr, node_ptr)
    {
       //Any nodes have no swap_nodes capability because they don't know
       //what algorithm they must use to unlink the node from the container

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

@@ -24,6 +24,7 @@
 #include <boost/config.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -63,7 +64,7 @@ class array_initializer
       BOOST_CATCH(...){
          while(i--){
             init_buf -= sizeof(T);
-            ((T*)init_buf)->~T();
+            move_detail::force_ptr<T*>(init_buf)->~T();
          }
          BOOST_RETHROW;
       }
@@ -81,7 +82,7 @@ class array_initializer
       char *init_buf = (char*)rawbuf + N*sizeof(T);
       for(std::size_t i = 0; i != N; ++i){
          init_buf -= sizeof(T);
-         ((T*)init_buf)->~T();
+         move_detail::force_ptr<T*>(init_buf)->~T();
       }
    }
 

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

@@ -69,40 +69,40 @@ struct default_avltree_node_traits_impl
 
    typedef typename node::balance balance;
 
-   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 balance get_balance(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const_node_ptr n)
    {  return n->balance_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(node_ptr n)
    {  return n->balance_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(const node_ptr & n, balance b)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(node_ptr n, balance b)
    {  n->balance_ = b;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static balance negative()
@@ -127,28 +127,28 @@ struct compact_avltree_node_traits_impl
 
    typedef pointer_plus_bits<node_ptr, 2> ptr_bit;
 
-   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 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 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 void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const_node_ptr n)
    {  return (balance)ptr_bit::get_bits(n->parent_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(const node_ptr & n, balance b)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(node_ptr n, balance b)
    {  ptr_bit::set_bits(n->parent_, (std::size_t)b);  }
 
    BOOST_INTRUSIVE_FORCEINLINE static balance negative()

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

@@ -42,7 +42,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr next_node(const node_ptr & node) BOOST_NOEXCEPT
+   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT
    {
       node_ptr const n_right(NodeTraits::get_right(node));
       if(n_right){
@@ -66,7 +66,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr prev_node(const node_ptr & node) BOOST_NOEXCEPT
+   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT
    {
       if(is_header(node)){
          return NodeTraits::get_right(node);
@@ -126,7 +126,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   static bool is_header(const const_node_ptr & p) BOOST_NOEXCEPT
+   static bool is_header(const_node_ptr p) BOOST_NOEXCEPT
    {
       node_ptr p_left (NodeTraits::get_left(p));
       node_ptr p_right(NodeTraits::get_right(p));
@@ -150,7 +150,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Logarithmic.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_header(const const_node_ptr & node)
+   static node_ptr get_header(const_node_ptr node)
    {
       node_ptr n(detail::uncast(node));
       node_ptr p(NodeTraits::get_parent(node));

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

@@ -40,7 +40,7 @@ class common_slist_algorithms
    typedef typename NodeTraits::const_node_ptr  const_node_ptr;
    typedef NodeTraits                           node_traits;
 
-   static node_ptr get_previous_node(node_ptr p, const node_ptr & this_node)
+   static node_ptr get_previous_node(node_ptr p, node_ptr this_node)
    {
       for( node_ptr p_next
          ; this_node != (p_next = NodeTraits::get_next(p))
@@ -55,13 +55,13 @@ class common_slist_algorithms
    BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & this_node)
+   static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       node_ptr next = NodeTraits::get_next(this_node);
       return !next || next == this_node;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node); }
 
    BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
@@ -73,20 +73,20 @@ class common_slist_algorithms
    BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(prev_node, last_node);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
+   static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
    {
       NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, this_node);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void incorporate_after(node_ptr bp, node_ptr b, node_ptr be)
+   static void incorporate_after(node_ptr bp, node_ptr b, node_ptr be) BOOST_NOEXCEPT
    {
       node_ptr p(NodeTraits::get_next(bp));
       NodeTraits::set_next(bp, b);
       NodeTraits::set_next(be, p);
    }
 
-   static void transfer_after(node_ptr bp, node_ptr bb, node_ptr be)
+   static void transfer_after(node_ptr bp, node_ptr bb, node_ptr be) BOOST_NOEXCEPT
    {
       if (bp != bb && bp != be && bb != be) {
          node_ptr next_b = NodeTraits::get_next(bb);
@@ -167,7 +167,7 @@ class common_slist_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t distance(const const_node_ptr &f, const const_node_ptr &l) BOOST_NOEXCEPT
+   static std::size_t distance(const_node_ptr f, const_node_ptr l) BOOST_NOEXCEPT
    {
       const_node_ptr i(f);
       std::size_t result = 0;
@@ -177,6 +177,75 @@ class common_slist_algorithms
       }
       return result;
    }
+
+   //! <b>Requires</b>: "disposer" must be an object function
+   //!   taking a node_ptr parameter and shouldn't throw.
+   //!
+   //! <b>Effects</b>: Calls
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the list
+   //!    [p, e).
+   //!
+   //! <b>Returns</b>: The number of unlinked/disposed nodes
+   //!
+   //! <b>Complexity</b>: Linear to the number of element of the list.
+   //!
+   //! <b>Throws</b>: Nothing.
+   template<class Disposer>
+   static std::size_t unlink_after_and_dispose(node_ptr bb, node_ptr e, Disposer disposer) BOOST_NOEXCEPT
+   {
+      std::size_t n = 0u;
+      node_ptr i = node_traits::get_next(bb);
+      while (i != e) {
+         node_ptr to_erase(i);
+         i = node_traits::get_next(i);
+         disposer(to_erase);
+         ++n;
+      }
+      node_traits::set_next(bb, e);
+      return n;
+   }
+
+   //! <b>Requires</b>: "disposer" must be an object function
+   //!   taking a node_ptr parameter and shouldn't throw.
+   //!
+   //! <b>Effects</b>: Calls
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the list
+   //!    after p (but not for p). Works for circular or linear lists
+   //!
+   //! <b>Complexity</b>: Linear to the number of element of the list.
+   //!
+   //! <b>Throws</b>: Nothing.
+   template<class Disposer>
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
+   {
+      node_ptr i = node_traits::get_next(bb);
+      node_traits::set_next(bb, node_traits::get_next(i));
+      disposer(i);
+   }
+
+   //! <b>Requires</b>: "disposer" must be an object function
+   //!   taking a node_ptr parameter and shouldn't throw.
+   //!
+   //! <b>Effects</b>: Unlinks all nodes reachable from p (but not p) and calls
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the list
+   //!    where p is linked.
+   //!
+   //! <b>Complexity</b>: Linear to the number of element of the list.
+   //!
+   //! <b>Throws</b>: Nothing.
+   template<class Disposer>
+   static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   {
+      std::size_t n = 0;
+      node_ptr i = node_traits::get_next(p);
+      while ( i != p || i != node_ptr() ) {
+         node_ptr to_erase(i);
+         i = node_traits::get_next(i);
+         disposer(to_erase);
+      }
+      node_traits::set_next(p, i);
+      return n;
+   }
 };
 
 /// @endcond

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{