passenger 5.1.4 → 5.1.5

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

@@ -48,7 +48,8 @@ struct make_any_base_hook
       >::type packed_options;
 
    typedef generic_hook
-   < any_algorithms<typename packed_options::void_pointer>
+   < AnyAlgorithm
+   , any_node_traits<typename packed_options::void_pointer>
    , typename packed_options::tag
    , packed_options::link_mode
    , AnyBaseHookId
@@ -153,7 +154,8 @@ struct make_any_member_hook
       >::type packed_options;
 
    typedef generic_hook
-   < any_algorithms<typename packed_options::void_pointer>
+   < AnyAlgorithm
+   , any_node_traits<typename packed_options::void_pointer>
    , member_tag
    , packed_options::link_mode
    , NoBaseHookId

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

@@ -26,6 +26,11 @@
 namespace boost {
 namespace intrusive {
 
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
+class avl_multiset_impl;
+#endif
+
 //! The class template avl_set is an intrusive container, that mimics most of
 //! the interface of std::set as described in the C++ standard.
 //!
@@ -82,9 +87,13 @@ class avl_set_impl
 
    public:
 
+   //! @copydoc ::boost::intrusive::avltree::avltree()
+   avl_set_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::avltree::avltree(const key_compare &,const value_traits &)
-   explicit avl_set_impl( const key_compare &cmp = key_compare()
-                    , const value_traits &v_traits = value_traits())
+   explicit avl_set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -146,6 +155,15 @@ class avl_set_impl
    //! @copydoc ::boost::intrusive::avltree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::avltree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::avltree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::avltree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::avltree::container_from_end_iterator(iterator)
    static avl_set_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -196,6 +214,17 @@ class avl_set_impl
    iterator insert(const_iterator hint, reference value)
    {  return tree_type::insert_unique(hint, value);  }
 
+   //! @copydoc ::boost::intrusive::avltree::insert_unique_check(const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const key_type &key, insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(key, commit_data); }
+
+   //! @copydoc ::boost::intrusive::avltree::insert_unique_check(const_iterator,const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const_iterator hint, const key_type &key
+      ,insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(hint, key, commit_data); }
+
    //! @copydoc ::boost::intrusive::avltree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator, bool> insert_check
@@ -321,21 +350,21 @@ class avl_set_impl
 
    #endif   //   #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
+   //! @copydoc ::boost::intrusive::avltree::equal_range(const key_type &)
    std::pair<iterator,iterator> equal_range(const key_type &key)
    {  return this->tree_type::lower_bound_range(key); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
+   //! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyTypeKeyCompare)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
    {  return this->tree_type::equal_range(key, comp); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
+   //! @copydoc ::boost::intrusive::avltree::equal_range(const key_type &)const
    std::pair<const_iterator, const_iterator>
       equal_range(const key_type &key) const
    {  return this->tree_type::lower_bound_range(key); }
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
+   //! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyTypeKeyCompare)const
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<const_iterator, const_iterator>
       equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
@@ -384,6 +413,26 @@ class avl_set_impl
 
    //! @copydoc ::boost::intrusive::avltree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::avltree::merge_unique
+   template<class ...Options2>
+   void merge(avl_set<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::avltree::merge_unique
+   template<class ...Options2>
+   void merge(avl_multiset<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(avl_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
+
+   template<class Compare2>
+   void merge(avl_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -476,8 +525,11 @@ class avl_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit avl_set( const key_compare &cmp = key_compare()
-                   , const value_traits &v_traits = value_traits())
+   avl_set()
+      :  Base()
+   {}
+
+   explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
@@ -573,9 +625,13 @@ class avl_multiset_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::avltree::avltree()
+   avl_multiset_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::avltree::avltree(const key_compare &,const value_traits &)
-   explicit avl_multiset_impl( const key_compare &cmp = key_compare()
-                         , const value_traits &v_traits = value_traits())
+   explicit avl_multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -636,6 +692,15 @@ class avl_multiset_impl
    //! @copydoc ::boost::intrusive::avltree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::avltree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::avltree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::avltree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::avltree::container_from_end_iterator(iterator)
    static avl_multiset_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -843,6 +908,25 @@ class avl_multiset_impl
 
    //! @copydoc ::boost::intrusive::avltree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::avltree::merge_equal
+   template<class ...Options2>
+   void merge(avl_multiset<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::avltree::merge_equal
+   template<class ...Options2>
+   void merge(avl_set<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(avl_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
+   template<class Compare2>
+   void merge(avl_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -936,8 +1020,11 @@ class avl_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit avl_multiset( const key_compare &cmp = key_compare()
-                        , const value_traits &v_traits = value_traits())
+   avl_multiset()
+      :  Base()
+   {}
+
+   explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 

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

@@ -47,7 +47,8 @@ struct make_avl_set_base_hook
       ::type packed_options;
 
    typedef generic_hook
-   < avltree_algorithms<avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size> >
+   < AvlTreeAlgorithms
+   , avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
    , typename packed_options::tag
    , packed_options::link_mode
    , AvlTreeBaseHookId
@@ -177,7 +178,8 @@ struct make_avl_set_member_hook
       ::type packed_options;
 
    typedef generic_hook
-   < avltree_algorithms<avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size> >
+   < AvlTreeAlgorithms
+   , avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
    , member_tag
    , packed_options::link_mode
    , NoBaseHookId

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

@@ -121,10 +121,13 @@ class avltree_impl
 
    typedef typename implementation_defined::insert_commit_data insert_commit_data;
 
+   //! @copydoc ::boost::intrusive::bstree::bstree()
+   avltree_impl()
+      :  tree_type()
+   {}
 
    //! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
-   explicit avltree_impl( const key_compare &cmp = key_compare()
-                       , const value_traits &v_traits = value_traits())
+   explicit avltree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -186,6 +189,15 @@ class avltree_impl
    //! @copydoc ::boost::intrusive::bstree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::bstree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::bstree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::bstree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::bstree::container_from_end_iterator(iterator)
    static avltree_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -257,6 +269,14 @@ class avltree_impl
       (const_iterator hint, const KeyType &key
       ,KeyTypeKeyCompare comp, insert_commit_data &commit_data);
 
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_unique_check
+      (const key_type &key, insert_commit_data &commit_data);
+
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_unique_check
+      (const_iterator hint, const key_type &key, insert_commit_data &commit_data);
+
    //! @copydoc ::boost::intrusive::bstree::insert_unique_commit
    iterator insert_unique_commit(reference value, const insert_commit_data &commit_data);
 
@@ -416,6 +436,14 @@ class avltree_impl
    //! @copydoc ::boost::intrusive::bstree::remove_node
    void remove_node(reference value);
 
+   //! @copydoc ::boost::intrusive::bstree::merge_unique(bstree<T, Options2...>&)
+   template<class T, class ...Options2>
+   void merge_unique(avltree<T, Options2...> &);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_equal(bstree<T, Options2...>&)
+   template<class T, class ...Options2>
+   void merge_equal(avltree<T, Options2...> &);
+
    friend bool operator< (const avltree_impl &x, const avltree_impl &y);
 
    friend bool operator==(const avltree_impl &x, const avltree_impl &y);
@@ -507,8 +535,11 @@ class avltree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit avltree( const key_compare &cmp = key_compare()
-                   , const value_traits &v_traits = value_traits())
+   avltree()
+      :  Base()
+   {}
+
+   explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 

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

@@ -269,14 +269,35 @@ class avltree_algorithms
    {
       typename bstree_algo::data_for_rebalance info;
       bstree_algo::erase(header, z, info);
-      if(info.y != z){
-         NodeTraits::set_balance(info.y, NodeTraits::get_balance(z));
-      }
-      //Rebalance avltree
-      rebalance_after_erasure(header, info.x, info.x_parent);
+      rebalance_after_erasure(header, z, info);
       return z;
    }
 
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_unique
+   template<class NodePtrCompare>
+   static bool transfer_unique
+      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
+   {
+      typename bstree_algo::data_for_rebalance info;
+      bool const transferred = bstree_algo::transfer_unique(header1, comp, header2, z, info);
+      if(transferred){
+         rebalance_after_erasure(header2, z, info);
+         rebalance_after_insertion(header1, z);
+      }
+      return transferred;
+   }
+
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_equal
+   template<class NodePtrCompare>
+   static void transfer_equal
+      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
+   {
+      typename bstree_algo::data_for_rebalance info;
+      bstree_algo::transfer_equal(header1, comp, header2, z, info);
+      rebalance_after_erasure(header2, z, info);
+      rebalance_after_insertion(header1, z);
+   }
+
    //! @copydoc ::boost::intrusive::bstree_algorithms::clone(const const_node_ptr&,const node_ptr&,Cloner,Disposer)
    template <class Cloner, class Disposer>
    static void clone
@@ -461,7 +482,17 @@ class avltree_algorithms
       return true;
    }
 
-   static void rebalance_after_erasure(const node_ptr & header, node_ptr x, node_ptr x_parent)
+   static void rebalance_after_erasure
+      ( const node_ptr & header, const node_ptr &z, const typename bstree_algo::data_for_rebalance &info)
+   {
+      if(info.y != z){
+         NodeTraits::set_balance(info.y, NodeTraits::get_balance(z));
+      }
+      //Rebalance avltree
+      rebalance_after_erasure_restore_invariants(header, info.x, info.x_parent);
+   }
+
+   static void rebalance_after_erasure_restore_invariants(const node_ptr & header, node_ptr x, node_ptr x_parent)
    {
       for ( node_ptr root = NodeTraits::get_parent(header)
           ; x != root

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

@@ -23,6 +23,11 @@
 #  pragma once
 #endif
 
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
+class bs_multiset_impl;
+#endif
+
 namespace boost {
 namespace intrusive {
 
@@ -80,9 +85,13 @@ class bs_set_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::bstree::bstree()
+   bs_set_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
-   explicit bs_set_impl( const key_compare &cmp = key_compare()
-                    , const value_traits &v_traits = value_traits())
+   explicit bs_set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -143,6 +152,15 @@ class bs_set_impl
    //! @copydoc ::boost::intrusive::bstree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::bstree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::bstree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::bstree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::bstree::container_from_end_iterator(iterator)
    static bs_set_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -193,6 +211,17 @@ class bs_set_impl
    iterator insert(const_iterator hint, reference value)
    {  return tree_type::insert_unique(hint, value);  }
 
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const key_type &key, insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(key, commit_data); }
+
+   //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const key_type&,insert_commit_data&)
+   std::pair<iterator, bool> insert_check
+      (const_iterator hint, const key_type &key
+      ,insert_commit_data &commit_data)
+   {  return tree_type::insert_unique_check(hint, key, commit_data); }
+
    //! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator, bool> insert_check
@@ -381,6 +410,26 @@ class bs_set_impl
 
    //! @copydoc ::boost::intrusive::bstree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_unique
+   template<class ...Options2>
+   void merge(bs_set<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_unique
+   template<class ...Options2>
+   void merge(bs_multiset<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(bs_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
+
+   template<class Compare2>
+   void merge(bs_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -473,8 +522,11 @@ class bs_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit bs_set( const key_compare &cmp = key_compare()
-                  , const value_traits &v_traits = value_traits())
+   bs_set()
+      :  Base()
+   {}
+
+   explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
@@ -569,9 +621,13 @@ class bs_multiset_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::bstree::bstree()
+   bs_multiset_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
-   explicit bs_multiset_impl( const key_compare &cmp = key_compare()
-                            , const value_traits &v_traits = value_traits())
+   explicit bs_multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -632,6 +688,15 @@ class bs_multiset_impl
    //! @copydoc ::boost::intrusive::bstree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::bstree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::bstree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::bstree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::bstree::container_from_end_iterator(iterator)
    static bs_multiset_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -839,6 +904,25 @@ class bs_multiset_impl
 
    //! @copydoc ::boost::intrusive::bstree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_equal
+   template<class ...Options2>
+   void merge(bs_multiset<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_equal
+   template<class ...Options2>
+   void merge(bs_set<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(bs_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
+   template<class Compare2>
+   void merge(bs_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -932,8 +1016,11 @@ class bs_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit bs_multiset( const key_compare &cmp = key_compare()
-                       , const value_traits &v_traits = value_traits())
+   bs_multiset()
+      :  Base()
+   {}
+
+   explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}