passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_list_algorithms.hpp

@@ -16,8 +16,8 @@
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #include <cstddef>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -67,7 +67,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT
+   static void init(node_ptr this_node) BOOST_NOEXCEPT
    {
       const node_ptr null_node = node_ptr();
       NodeTraits::set_next(this_node, null_node);
@@ -80,7 +80,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr &this_node) BOOST_NOEXCEPT
+   inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node); }
 
    //! <b>Effects</b>: Constructs an empty list, making this_node the only
@@ -91,12 +91,22 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {
       NodeTraits::set_next(this_node, this_node);
       NodeTraits::set_previous(this_node, this_node);
    }
 
+   //! <b>Effects</b>: Returns true if this_node_points to an empty list.
+   //! 
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   {
+      return NodeTraits::get_next(this_node) == this_node;
+   }
+
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
    //!
    //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list:
@@ -105,7 +115,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr &this_node) BOOST_NOEXCEPT
+   static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       node_ptr next = NodeTraits::get_next(this_node);
       return !next || next == this_node;
@@ -119,7 +129,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t count(const const_node_ptr &this_node) BOOST_NOEXCEPT
+   static std::size_t count(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       std::size_t result = 0;
       const_node_ptr p = this_node;
@@ -137,7 +147,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr unlink(node_ptr this_node) BOOST_NOEXCEPT
+   static node_ptr unlink(node_ptr this_node) BOOST_NOEXCEPT
    {
       node_ptr next(NodeTraits::get_next(this_node));
       node_ptr prev(NodeTraits::get_previous(this_node));
@@ -153,7 +163,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink(node_ptr b, node_ptr e) BOOST_NOEXCEPT
+   static void unlink(node_ptr b, node_ptr e) BOOST_NOEXCEPT
    {
       if (b != e) {
          node_ptr prevb(NodeTraits::get_previous(b));
@@ -169,7 +179,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void link_before(node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
+   static void link_before(node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
    {
       node_ptr prev(NodeTraits::get_previous(nxt_node));
       NodeTraits::set_previous(this_node, prev);
@@ -188,7 +198,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   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
    {
       node_ptr next(NodeTraits::get_next(prev_node));
       NodeTraits::set_previous(this_node, prev_node);
@@ -358,12 +368,11 @@ class circular_list_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;
-      while(i != l){
-         i = NodeTraits::get_next(i);
+      while(f != l){
+         f = NodeTraits::get_next(f);
          ++result;
       }
       return result;
@@ -396,7 +405,7 @@ class circular_list_algorithms
             new_f = cur;
             bcur = cur;
             cur  = node_traits::get_next(cur);
-            BOOST_TRY{
+            BOOST_INTRUSIVE_TRY{
                //Main loop
                while(cur != end){
                   if(pred(cur)){ //Might throw
@@ -417,12 +426,12 @@ class circular_list_algorithms
                   }
                }
             }
-            BOOST_CATCH(...){
+            BOOST_INTRUSIVE_CATCH(...){
                node_traits::set_next    (last_to_remove, new_f);
                node_traits::set_previous(new_f, last_to_remove);
-               BOOST_RETHROW;
+               BOOST_INTRUSIVE_RETHROW;
             }
-            BOOST_CATCH_END
+            BOOST_INTRUSIVE_CATCH_END
             node_traits::set_next(last_to_remove, new_f);
             node_traits::set_previous(new_f, last_to_remove);
             break;
@@ -434,14 +443,14 @@ class circular_list_algorithms
    }
 
    private:
-   BOOST_INTRUSIVE_FORCEINLINE static void swap_prev(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
+   static void swap_prev(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
    {
       node_ptr temp(NodeTraits::get_previous(this_node));
       NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
       NodeTraits::set_previous(other_node, temp);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void swap_next(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
+   static void swap_next(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
    {
       node_ptr temp(NodeTraits::get_next(this_node));
       NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));

data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_slist_algorithms.hpp

@@ -18,6 +18,7 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/detail/common_slist_algorithms.hpp>
+#include <boost/intrusive/detail/uncast.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -131,6 +132,10 @@ class circular_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    static void transfer_after(node_ptr p, node_ptr b, node_ptr e) BOOST_NOEXCEPT;
+   
+   #else
+
+   using base_t::transfer_after;
 
    #endif   //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
@@ -141,9 +146,44 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);  }
 
+   //! <b>Requires</b>: 'p' is the first node of a list.
+   //!
+   //! <b>Effects</b>: Returns a pointer to a node that represents the "end" (one past end) node
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   inline static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
+   {  return detail::uncast(p);   }
+
+   //! <b>Effects</b>: Returns true if this_node_points to an empty list.
+   //! 
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   {  return NodeTraits::get_next(this_node) == this_node;  }
+
+   //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
+   //! 
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   {  return NodeTraits::get_next(this_node) == node_ptr();  }
+
+   //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
+   //!                 that can be used to mark a special state of the list
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   {  NodeTraits::set_next(this_node, node_ptr());   }
+
    //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list.
    //!
    //! <b>Effects</b>: Returns the previous node of this_node in the circular list starting.
@@ -153,7 +193,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -163,7 +203,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr & this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -173,7 +213,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(const node_ptr & this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return get_previous_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node and p must be in the same circular list.
@@ -185,7 +225,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_previous_previous_node(node_ptr p, const node_ptr & this_node) BOOST_NOEXCEPT
+   static node_ptr get_previous_previous_node(node_ptr p, node_ptr this_node) BOOST_NOEXCEPT
    {
       node_ptr p_next = NodeTraits::get_next(p);
       node_ptr p_next_next = NodeTraits::get_next(p_next);
@@ -205,7 +245,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t count(const const_node_ptr & this_node) BOOST_NOEXCEPT
+   static std::size_t count(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       std::size_t result = 0;
       const_node_ptr p = this_node;
@@ -223,7 +263,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink(node_ptr this_node) BOOST_NOEXCEPT
+   static void unlink(node_ptr this_node) BOOST_NOEXCEPT
    {
       if(NodeTraits::get_next(this_node))
          base_t::unlink_after(get_previous_node(this_node));
@@ -236,7 +276,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
+   inline static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
    {  base_t::link_after(get_previous_node(nxt_node), this_node);   }
 
    //! <b>Requires</b>: this_node and other_node must be nodes inserted
@@ -386,6 +426,35 @@ class circular_slist_algorithms
       base_t::link_after(new_last, p);
       return new_last;
    }
+
+   //! <b>Requires</b>: other must be a list and p must be a node of a different list.
+   //!
+   //! <b>Effects</b>: Transfers all nodes from other after p in p's list.
+   //!
+   //! <b>Complexity</b>: Linear
+   //!
+   //! <b>Throws</b>: Nothing.
+   static void transfer_after(node_ptr p, node_ptr other) BOOST_NOEXCEPT
+   {
+      node_ptr other_last((get_previous_node)(other));
+      base_t::transfer_after(p, other, other_last);
+   }
+
+   //! <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>Returns</b>: The number of disposed nodes
+   //!
+   //! <b>Complexity</b>: Linear to the number of element of the list.
+   //!
+   //! <b>Throws</b>: Nothing.
+   template<class Disposer>
+   inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   {  return base_t::unlink_after_and_dispose(p, p, disposer);   }
 };
 
 /// @cond

data/src/cxx_supportlib/vendor-modified/boost/intrusive/derivation_value_traits.hpp

@@ -58,12 +58,12 @@ struct derivation_value_traits
    BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) BOOST_NOEXCEPT
    { return node_ptr(&value); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr &n) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) BOOST_NOEXCEPT
    {
       return pointer_traits<pointer>::pointer_to(static_cast<reference>(*n));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr &n) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n) BOOST_NOEXCEPT
    {
       return pointer_traits<const_pointer>::pointer_to(static_cast<const_reference>(*n));
    }

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

@@ -26,15 +26,15 @@ namespace intrusive {
 
 struct algo_pred_equal
 {
-   template<class T>
-   bool operator()(const T &x, const T &y) const
+   template<class T, class T2>
+   bool operator()(const T &x, const T2 &y) const
    {  return x == y;  }
 };
 
 struct algo_pred_less
 {
-   template<class T>
-   bool operator()(const T &x, const T &y) const
+   template<class T, class T2>
+   bool operator()(const T &x, const T2 &y) const
    {  return x < y;  }
 };
 
@@ -49,10 +49,6 @@ bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicat
     return true;
 }
 
-template<class InputIt1, class InputIt2>
-bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
-{  return (algo_equal)(first1, last1, first2, algo_pred_equal());  }
-
 template<class InputIt1, class InputIt2, class BinaryPredicate>
 bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate pred)
 {
@@ -62,6 +58,10 @@ bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2
     return first1 == last1 && first2 == last2;
 }
 
+template<class InputIt1, class InputIt2>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
+{  return (algo_equal)(first1, last1, first2, algo_pred_equal());  }
+
 template<class InputIt1, class InputIt2>
 bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
 {  return (algo_equal)(first1, last1, first2, last2, algo_pred_equal());  }

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)
@@ -243,7 +243,7 @@ class any_algorithms
    typedef typename node::const_node_ptr  const_node_ptr;
    typedef any_node_traits<VoidPointer>   node_traits;
 
-   //! <b>Requires</b>: node must not be part of any tree.
+   //! <b>Requires</b>: 'n' must not be part of any tree.
    //!
    //! <b>Effects</b>: After the function unique(node) == true.
    //!
@@ -252,27 +252,27 @@ 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
-   {  node->node_ptr_1 = node_ptr();   };
+   inline static void init(node_ptr n) BOOST_NOEXCEPT
+   {  n->node_ptr_1 = node_ptr();   };
 
-   //! <b>Effects</b>: Returns true if node is in the same state as if called init(node)
+   //! <b>Effects</b>: Returns true if 'n' is in the same state as if called init(node)
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & node)
-   {  return !node->node_ptr_1;  };
+   inline static bool inited(const_node_ptr n)
+   {  return !n->node_ptr_1;  };
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & node) BOOST_NOEXCEPT
-   {  return !node->node_ptr_1; }
+   inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT
+   {  return !n->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

@@ -22,8 +22,9 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -54,20 +55,20 @@ class array_initializer
    {
       char *init_buf = (char*)rawbuf;
       std::size_t i = 0;
-      BOOST_TRY{
+      BOOST_INTRUSIVE_TRY{
          for(; i != N; ++i){
             ::new(init_buf, boost_move_new_t()) T(init);
             init_buf += sizeof(T);
          }
       }
-      BOOST_CATCH(...){
+      BOOST_INTRUSIVE_CATCH(...){
          while(i--){
             init_buf -= sizeof(T);
-            ((T*)init_buf)->~T();
+            move_detail::force_ptr<T*>(init_buf)->~T();
          }
-         BOOST_RETHROW;
+         BOOST_INTRUSIVE_RETHROW;
       }
-      BOOST_CATCH_END
+      BOOST_INTRUSIVE_CATCH_END
    }
 
    operator T* ()
@@ -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();
       }
    }