passenger 5.1.4 → 5.1.5

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

@@ -569,6 +569,34 @@ class treap_algorithms
       rotate_up_n(header, new_node, commit_data.rotations);
    }
 
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_unique
+   template<class NodePtrCompare, class KeyNodePtrPrioCompare>
+   static bool transfer_unique
+      (const node_ptr & header1, NodePtrCompare comp, KeyNodePtrPrioCompare pcomp, const node_ptr &header2, const node_ptr & z)
+   {
+      insert_commit_data commit_data;
+      bool const transferable = insert_unique_check(header1, z, comp, pcomp, commit_data).second;
+      if(transferable){
+         erase(header2, z, pcomp);
+         insert_unique_commit(header1, z, commit_data);         
+      }
+      return transferable;
+   }
+
+   //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_equal
+   template<class NodePtrCompare, class KeyNodePtrPrioCompare>
+   static void transfer_equal
+      (const node_ptr & header1, NodePtrCompare comp, KeyNodePtrPrioCompare pcomp, const node_ptr &header2, const node_ptr & z)
+   {
+      insert_commit_data commit_data;
+      bstree_algo::insert_equal_upper_bound_check(header1, z, comp, commit_data);
+      rebalance_after_insertion_check(header1, commit_data.node, z, pcomp, commit_data.rotations);
+      rebalance_for_erasure(header2, z, pcomp);
+      bstree_algo::erase(header2, z);
+      bstree_algo::insert_unique_commit(header1, z, commit_data);
+      rotate_up_n(header1, z, commit_data.rotations);
+   }
+
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::is_header

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

@@ -26,6 +26,11 @@
 namespace boost {
 namespace intrusive {
 
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
+class treap_multiset_impl;
+#endif
+
 //! The class template treap_set is an intrusive container, that mimics most of
 //! the interface of std::set as described in the C++ standard.
 //!
@@ -83,31 +88,19 @@ class treap_set_impl
    static const bool constant_time_size = implementation_defined::constant_time_size;
 
    public:
-   //! <b>Effects</b>: Constructs an empty treap_set.
-   //!
-   //! <b>Complexity</b>: Constant.
-   //!
-   //! <b>Throws</b>: If value_traits::node_traits::node
-   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or the copy constructor of the key_compare object throws.
-   explicit treap_set_impl( const key_compare &cmp      = key_compare()
+   //! @copydoc ::boost::intrusive::treap::treap()
+   treap_set_impl()
+      :  tree_type()
+   {}
+
+   //! @copydoc ::boost::intrusive::treap::treap(const key_compare &,const priority_compare &,const value_traits &)
+   explicit treap_set_impl( const key_compare &cmp
                           , const priority_compare &pcmp  = priority_compare()
                           , const value_traits &v_traits  = value_traits())
       :  tree_type(cmp, pcmp, v_traits)
    {}
 
-   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type.
-   //!   cmp must be a comparison function that induces a strict weak ordering.
-   //!
-   //! <b>Effects</b>: Constructs an empty treap_set and inserts elements from
-   //!   [b, e).
-   //!
-   //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using
-   //!   comp and otherwise N * log N, where N is distance(last, first).
-   //!
-   //! <b>Throws</b>: If value_traits::node_traits::node
-   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or the copy constructor/operator() of the key_compare object throws.
+   //! @copydoc ::boost::intrusive::treap::treap(bool,Iterator,Iterator,const key_compare &,const priority_compare &,const value_traits &)
    template<class Iterator>
    treap_set_impl( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
@@ -167,6 +160,15 @@ class treap_set_impl
    //! @copydoc ::boost::intrusive::treap::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::treap::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::treap::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::treap::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::treap::container_from_end_iterator(iterator)
    static treap_set_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -241,6 +243,15 @@ class treap_set_impl
    iterator insert(const_iterator hint, reference value)
    {  return tree_type::insert_unique(hint, value);  }
 
+   //! @copydoc ::boost::intrusive::treap::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::treap::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::treap::insert_unique_check(const KeyType&,KeyTypeKeyCompare,KeyValuePrioCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare, class KeyValuePrioCompare>
    std::pair<iterator, bool> insert_check
@@ -368,21 +379,21 @@ class treap_set_impl
 
    #endif   //   #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
+   //! @copydoc ::boost::intrusive::treap::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::treap::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::treap::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::treap::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
@@ -432,6 +443,25 @@ class treap_set_impl
    //! @copydoc ::boost::intrusive::treap::remove_node
    void remove_node(reference value);
 
+
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(treap_set<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(treap_multiset<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(treap_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
+   template<class Compare2>
+   void merge(treap_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -508,7 +538,11 @@ class treap_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 treap_set( const key_compare &cmp    = key_compare()
+   treap_set()
+      :  Base()
+   {}
+
+   explicit treap_set( const key_compare &cmp
                      , const priority_compare &pcmp = priority_compare()
                      , const value_traits &v_traits = value_traits())
       :  Base(cmp, pcmp, v_traits)
@@ -608,31 +642,20 @@ class treap_multiset_impl
    static const bool constant_time_size = implementation_defined::constant_time_size;
 
    public:
-   //! <b>Effects</b>: Constructs an empty treap_multiset.
-   //!
-   //! <b>Complexity</b>: Constant.
-   //!
-   //! <b>Throws</b>: If value_traits::node_traits::node
-   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or the copy constructor of the key_compare object throws.
-   explicit treap_multiset_impl( const key_compare &cmp      = key_compare()
+
+   //! @copydoc ::boost::intrusive::treap::treap()
+   treap_multiset_impl()
+      :  tree_type()
+   {}
+
+   //! @copydoc ::boost::intrusive::treap::treap(const key_compare &,const priority_compare &,const value_traits &)
+   explicit treap_multiset_impl( const key_compare &cmp
                           , const priority_compare &pcmp  = priority_compare()
                           , const value_traits &v_traits  = value_traits())
       :  tree_type(cmp, pcmp, v_traits)
    {}
 
-   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type.
-   //!   cmp must be a comparison function that induces a strict weak ordering.
-   //!
-   //! <b>Effects</b>: Constructs an empty treap_multiset and inserts elements from
-   //!   [b, e).
-   //!
-   //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using
-   //!   comp and otherwise N * log N, where N is distance(last, first).
-   //!
-   //! <b>Throws</b>: If value_traits::node_traits::node
-   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or the copy constructor/operator() of the key_compare object throws.
+   //! @copydoc ::boost::intrusive::treap::treap(bool,Iterator,Iterator,const key_compare &,const priority_compare &,const value_traits &)
    template<class Iterator>
    treap_multiset_impl( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
@@ -692,6 +715,15 @@ class treap_multiset_impl
    //! @copydoc ::boost::intrusive::treap::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::treap::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::treap::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::treap::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::treap::container_from_end_iterator(iterator)
    static treap_multiset_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -924,6 +956,24 @@ class treap_multiset_impl
    //! @copydoc ::boost::intrusive::treap::remove_node
    void remove_node(reference value);
 
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(treap_multiset<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::treap::merge_unique
+   template<class ...Options2>
+   void merge(treap_set<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(treap_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
+   template<class Compare2>
+   void merge(treap_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 };
 
@@ -1000,7 +1050,11 @@ class treap_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 treap_multiset( const key_compare &cmp    = key_compare()
+   treap_multiset()
+      :  Base()
+   {}
+
+   explicit treap_multiset( const key_compare &cmp
                           , const priority_compare &pcmp = priority_compare()
                           , const value_traits &v_traits = value_traits())
       :  Base(cmp, pcmp, v_traits)

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

@@ -14,6 +14,7 @@
 #define BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
@@ -42,12 +43,12 @@ struct trivial_value_traits
    typedef node_ptr                                            pointer;
    typedef const_node_ptr                                      const_pointer;
    static const link_mode_type link_mode = LinkMode;
-   static node_ptr       to_node_ptr (value_type &value)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr       to_node_ptr (value_type &value)
       {  return pointer_traits<node_ptr>::pointer_to(value);  }
-   static const_node_ptr to_node_ptr (const value_type &value)
+   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr (const value_type &value)
       {  return pointer_traits<const_node_ptr>::pointer_to(value);  }
-   static const pointer  &      to_value_ptr(const node_ptr &n)        {  return n; }
-   static const const_pointer  &to_value_ptr(const const_node_ptr &n)  {  return n; }
+   BOOST_INTRUSIVE_FORCEINLINE static const pointer  &      to_value_ptr(const node_ptr &n)        {  return n; }
+   BOOST_INTRUSIVE_FORCEINLINE static const const_pointer  &to_value_ptr(const const_node_ptr &n)  {  return n; }
 };
 
 } //namespace intrusive

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

@@ -120,7 +120,7 @@ class unordered_set_impl
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   explicit unordered_set_impl( const bucket_traits &b_traits
+   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_set_impl( const bucket_traits &b_traits
                               , const hasher & hash_func = hasher()
                               , const key_equal &equal_func = key_equal()
                               , const value_traits &v_traits = value_traits())
@@ -129,7 +129,7 @@ class unordered_set_impl
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
    template<class Iterator>
-   unordered_set_impl( Iterator b
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl( Iterator b
                      , Iterator e
                      , const bucket_traits &b_traits
                      , const hasher & hash_func = hasher()
@@ -139,12 +139,12 @@ class unordered_set_impl
    {}
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(hashtable&&)
-   unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! @copydoc ::boost::intrusive::hashtable::operator=(hashtable&&)
-   unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
    {  return static_cast<unordered_set_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -196,26 +196,30 @@ class unordered_set_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
    {  table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique(reference)
-   std::pair<iterator, bool> insert(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert(reference value)
    {  return table_type::insert_unique(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator)
    template<class Iterator>
-   void insert(Iterator b, Iterator e)
+   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
    {  table_type::insert_unique(b, e);  }
 
+   //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const key_type&,insert_commit_data&)
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check(const key_type &key, insert_commit_data &commit_data)
+   {  return table_type::insert_unique_check(key, commit_data); }
+
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const KeyType&,KeyHasher,KeyEqual,insert_commit_data&)
    template<class KeyType, class KeyHasher, class KeyEqual>
-   std::pair<iterator, bool> insert_check
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check
       (const KeyType &key, KeyHasher hasher, KeyEqual key_value_equal, insert_commit_data &commit_data)
    {  return table_type::insert_unique_check(key, hasher, key_value_equal, commit_data); }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_commit
-   iterator insert_commit(reference value, const insert_commit_data &commit_data)
+   BOOST_INTRUSIVE_FORCEINLINE iterator insert_commit(reference value, const insert_commit_data &commit_data)
    {  return table_type::insert_unique_commit(value, commit_data); }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -356,6 +360,9 @@ class unordered_set_impl
    //! @copydoc ::boost::intrusive::hashtable::rehash(const bucket_traits &)
    void rehash(const bucket_traits &new_bucket_traits);
 
+   //! @copydoc ::boost::intrusive::hashtable::full_rehash
+   void full_rehash();
+
    //! @copydoc ::boost::intrusive::hashtable::incremental_rehash(bool)
    bool incremental_rehash(bool grow = true);
 
@@ -499,8 +506,8 @@ class unordered_set
    {}
 
    template<class Iterator>
-   unordered_set  ( Iterator b
-                  , Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set
+                  ( Iterator b, Iterator e
                   , const bucket_traits &b_traits
                   , const hasher & hash_func = hasher()
                   , const key_equal &equal_func = key_equal()
@@ -508,19 +515,19 @@ class unordered_set
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   unordered_set(BOOST_RV_REF(unordered_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set(BOOST_RV_REF(unordered_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
    {  return static_cast<unordered_set&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };
 
@@ -609,7 +616,7 @@ class unordered_multiset_impl
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   explicit unordered_multiset_impl ( const bucket_traits &b_traits
+   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_multiset_impl ( const bucket_traits &b_traits
                                     , const hasher & hash_func = hasher()
                                     , const key_equal &equal_func = key_equal()
                                     , const value_traits &v_traits = value_traits())
@@ -618,7 +625,7 @@ class unordered_multiset_impl
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
    template<class Iterator>
-   unordered_multiset_impl ( Iterator b
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl ( Iterator b
                            , Iterator e
                            , const bucket_traits &b_traits
                            , const hasher & hash_func = hasher()
@@ -629,13 +636,13 @@ class unordered_multiset_impl
 
    //! <b>Effects</b>: to-do
    //!
-   unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! <b>Effects</b>: to-do
    //!
-   unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
    {  return static_cast<unordered_multiset_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x)));  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -688,16 +695,16 @@ class unordered_multiset_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
    {  table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_equal(reference)
-   iterator insert(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE iterator insert(reference value)
    {  return table_type::insert_equal(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator)
    template<class Iterator>
-   void insert(Iterator b, Iterator e)
+   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
    {  table_type::insert_equal(b, e);  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -832,6 +839,9 @@ class unordered_multiset_impl
    //! @copydoc ::boost::intrusive::hashtable::rehash(const bucket_traits &)
    void rehash(const bucket_traits &new_bucket_traits);
 
+   //! @copydoc ::boost::intrusive::hashtable::full_rehash
+   void full_rehash();
+
    //! @copydoc ::boost::intrusive::hashtable::incremental_rehash(bool)
    bool incremental_rehash(bool grow = true);
 
@@ -944,7 +954,7 @@ class unordered_multiset
       :  Base(b_traits, hash_func, equal_func, v_traits)
    {}
 
-   template<class Iterator>
+   template<class Iterator> BOOST_INTRUSIVE_FORCEINLINE
    unordered_multiset( Iterator b
                      , Iterator e
                      , const bucket_traits &b_traits
@@ -954,19 +964,19 @@ class unordered_multiset
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
    {  return static_cast<unordered_multiset&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };