passenger 6.0.14 → 6.0.27

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

@@ -17,7 +17,6 @@
 #include <boost/intrusive/treap.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -215,22 +214,22 @@ class treap_set_impl
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
    //! @copydoc ::boost::intrusive::treap::top()
-   BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT;
+   inline iterator top() BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::top()const
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT;
+   inline const_iterator top() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::ctop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT;
+   inline const_iterator ctop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::rtop()
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT;
+   inline reverse_iterator rtop() BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::rtop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT;
+   inline const_reverse_iterator rtop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::crtop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crtop() const BOOST_NOEXCEPT;
+   inline const_reverse_iterator crtop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::crtop() const
    priority_compare priority_comp() const;
@@ -540,51 +539,55 @@ class treap_set
    typedef typename Base::const_iterator     const_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_set()
+   inline treap_set()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit treap_set( const key_compare &cmp
+   inline 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)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE treap_set( Iterator b, Iterator e
+   inline treap_set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const priority_compare &pcmp = priority_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, pcmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_set(BOOST_RV_REF(treap_set) x)
+   inline treap_set(BOOST_RV_REF(treap_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_set& operator=(BOOST_RV_REF(treap_set) x)
+   inline treap_set& operator=(BOOST_RV_REF(treap_set) x)
    {  return static_cast<treap_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const treap_set &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const treap_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(treap_set) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(treap_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static treap_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static treap_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const treap_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static const treap_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const treap_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static treap_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static treap_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<treap_set &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const treap_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static const treap_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const treap_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -774,22 +777,22 @@ class treap_multiset_impl
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
    //! @copydoc ::boost::intrusive::treap::top()
-   BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT;
+   inline iterator top() BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::top()const
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT;
+   inline const_iterator top() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::ctop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT;
+   inline const_iterator ctop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::rtop()
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT;
+   inline reverse_iterator rtop() BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::rtop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT;
+   inline const_reverse_iterator rtop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::crtop()const
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crtop() const BOOST_NOEXCEPT;
+   inline const_reverse_iterator crtop() const BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::treap::crtop() const
    priority_compare priority_comp() const;
@@ -1055,51 +1058,55 @@ class treap_multiset
    typedef typename Base::const_iterator     const_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_multiset()
+   inline treap_multiset()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit treap_multiset( const key_compare &cmp
+   inline 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)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE treap_multiset( Iterator b, Iterator e
+   inline treap_multiset( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const priority_compare &pcmp = priority_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, pcmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_multiset(BOOST_RV_REF(treap_multiset) x)
+   inline treap_multiset(BOOST_RV_REF(treap_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x)
+   inline treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x)
    {  return static_cast<treap_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const treap_multiset &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const treap_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(treap_multiset) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(treap_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static treap_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static treap_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const treap_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static const treap_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const treap_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static treap_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static treap_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<treap_multiset &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const treap_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   inline static const treap_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const treap_multiset &>(Base::container_from_iterator(it));   }
 };
 

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

@@ -47,9 +47,9 @@ struct trivial_value_traits
       {  return pointer_traits<node_ptr>::pointer_to(value);  }
    BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr (const value_type &value) BOOST_NOEXCEPT
       {  return pointer_traits<const_node_ptr>::pointer_to(value);  }
-   BOOST_INTRUSIVE_FORCEINLINE static const pointer  &      to_value_ptr(const node_ptr &n) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer  to_value_ptr(node_ptr n) BOOST_NOEXCEPT
       {  return n; }
-   BOOST_INTRUSIVE_FORCEINLINE static const 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 n; }
 };
 

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

@@ -17,7 +17,6 @@
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/hashtable.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -67,7 +66,9 @@ template<class T, class ...Options>
 template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyHash, class VoidOrKeyEqual, class SizeType, class BucketTraits, std::size_t BoolFlags>
 #endif
 class unordered_set_impl
+   #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    : public hashtable_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrKeyEqual, BucketTraits, SizeType, BoolFlags|hash_bool_flags::unique_keys_pos>
+   #endif
 {
    /// @cond
    private:
@@ -115,12 +116,11 @@ class unordered_set_impl
    typedef typename implementation_defined::node                        node;
    typedef typename implementation_defined::node_ptr                    node_ptr;
    typedef typename implementation_defined::const_node_ptr              const_node_ptr;
-   typedef typename implementation_defined::node_algorithms             node_algorithms;
 
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_set_impl( const bucket_traits &b_traits
+   inline 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>
-   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl( Iterator b
+   inline 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&&)
-   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
+   inline unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! @copydoc ::boost::intrusive::hashtable::operator=(hashtable&&)
-   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
+   inline 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,32 +196,36 @@ class unordered_set_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
+   inline 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)
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert(reference value)
+   inline std::pair<iterator, bool> insert(reference value)
    {  return table_type::insert_unique(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator)
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
+   inline 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)
+   inline 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>
-   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); }
+   inline std::pair<iterator, bool> insert_check
+      (const KeyType &key, KeyHasher hash_func, KeyEqual key_value_equal, insert_commit_data &commit_data)
+   {  return table_type::insert_unique_check(key, hash_func, key_value_equal, commit_data); }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_commit
-   BOOST_INTRUSIVE_FORCEINLINE iterator insert_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
+   inline iterator insert_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
    {  return table_type::insert_unique_commit(value, commit_data); }
 
+   //! @copydoc ::boost::intrusive::hashtable::insert_unique_fast_commit
+   inline iterator insert_fast_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
+   {  return table_type::insert_unique_fast_commit(value, commit_data); }
+
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
    //! @copydoc ::boost::intrusive::hashtable::erase(const_iterator)
@@ -276,7 +280,7 @@ class unordered_set_impl
    template<class KeyType, class KeyHasher, class KeyEqual>
    iterator find(const KeyType& key, KeyHasher hash_func, KeyEqual equal_func);
 
-   //! @copydoc ::boost::intrusive::hashtable::count(const key_type &)const
+   //! @copydoc ::boost::intrusive::hashtable::find(const key_type &)const
    const_iterator find(const key_type &key) const;
 
    //! @copydoc ::boost::intrusive::hashtable::find(const KeyType &,KeyHasher,KeyEqual)const
@@ -420,6 +424,7 @@ template<class T, class O1 = void, class O2 = void
                 , class O5 = void, class O6 = void
                 , class O7 = void, class O8 = void
                 , class O9 = void, class O10= void
+                , class O11 = void
                 >
 #endif
 struct make_unordered_set
@@ -428,7 +433,7 @@ struct make_unordered_set
    typedef typename pack_options
       < hashtable_defaults,
          #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
+         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11
          #else
          Options...
          #endif
@@ -438,7 +443,7 @@ struct make_unordered_set
       <T, typename packed_options::proto_value_traits>::type value_traits;
 
    typedef typename make_bucket_traits
-            <T, true, packed_options>::type bucket_traits;
+            <T, packed_options>::type bucket_traits;
 
    typedef unordered_set_impl
       < value_traits
@@ -453,6 +458,8 @@ struct make_unordered_set
       |  (std::size_t(packed_options::cache_begin)*hash_bool_flags::cache_begin_pos)
       |  (std::size_t(packed_options::compare_hash)*hash_bool_flags::compare_hash_pos)
       |  (std::size_t(packed_options::incremental)*hash_bool_flags::incremental_pos)
+      |  (std::size_t(packed_options::linear_buckets)*hash_bool_flags::linear_buckets_pos)
+      |  (std::size_t(packed_options::fastmod_buckets)*hash_bool_flags::fastmod_buckets_pos)
       > implementation_defined;
 
    /// @endcond
@@ -462,30 +469,29 @@ struct make_unordered_set
 #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10>
+template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10, class O11>
 #else
 template<class T, class ...Options>
 #endif
 class unordered_set
    :  public make_unordered_set<T,
          #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
+         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11
          #else
          Options...
          #endif
       >::type
 {
-   typedef typename make_unordered_set
-      <T,
+   typedef typename make_unordered_set<T,
          #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
+         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11
          #else
          Options...
          #endif
-      >::type   Base;
+      >::type Base;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_set)
 
    public:
@@ -498,7 +504,7 @@ class unordered_set
    typedef typename Base::hasher             hasher;
    typedef typename Base::key_equal          key_equal;
 
-   BOOST_INTRUSIVE_FORCEINLINE
+   inline
    explicit unordered_set  ( const bucket_traits &b_traits
                            , const hasher & hash_func = hasher()
                            , const key_equal &equal_func = key_equal()
@@ -507,7 +513,7 @@ class unordered_set
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE
+   inline
    unordered_set
                   ( Iterator b, Iterator e
                   , const bucket_traits &b_traits
@@ -517,20 +523,20 @@ class unordered_set
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE unordered_set(BOOST_RV_REF(unordered_set) x)
+   inline unordered_set(BOOST_RV_REF(unordered_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+   inline 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>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
-   {  Base::clone_from(src, cloner, disposer);  }
+   inline void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
+   {  this->Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class 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);  }
+   inline void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
+   {  this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };
 
 #endif
@@ -577,7 +583,9 @@ template<class T, class ...Options>
 template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyHash, class VoidOrKeyEqual, class SizeType, class BucketTraits, std::size_t BoolFlags>
 #endif
 class unordered_multiset_impl
+   #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    : public hashtable_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrKeyEqual, BucketTraits, SizeType, BoolFlags>
+   #endif
 {
    /// @cond
    private:
@@ -613,12 +621,11 @@ class unordered_multiset_impl
    typedef typename implementation_defined::node                        node;
    typedef typename implementation_defined::node_ptr                    node_ptr;
    typedef typename implementation_defined::const_node_ptr              const_node_ptr;
-   typedef typename implementation_defined::node_algorithms             node_algorithms;
 
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_multiset_impl ( const bucket_traits &b_traits
+   inline 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())
@@ -627,7 +634,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>
-   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl ( Iterator b
+   inline unordered_multiset_impl ( Iterator b
                            , Iterator e
                            , const bucket_traits &b_traits
                            , const hasher & hash_func = hasher()
@@ -638,13 +645,13 @@ class unordered_multiset_impl
 
    //! <b>Effects</b>: to-do
    //!
-   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
+   inline unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! <b>Effects</b>: to-do
    //!
-   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
+   inline 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
@@ -697,16 +704,16 @@ class unordered_multiset_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
+   inline 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)
-   BOOST_INTRUSIVE_FORCEINLINE iterator insert(reference value)
+   inline iterator insert(reference value)
    {  return table_type::insert_equal(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator)
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
+   inline void insert(Iterator b, Iterator e)
    {  table_type::insert_equal(b, e);  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -763,7 +770,7 @@ class unordered_multiset_impl
    template<class KeyType, class KeyHasher, class KeyEqual>
    iterator find(const KeyType& key, KeyHasher hash_func, KeyEqual equal_func);
 
-   //! @copydoc ::boost::intrusive::hashtable::count(const key_type &)const
+   //! @copydoc ::boost::intrusive::hashtable::find(const key_type &)const
    const_iterator find(const key_type &key) const;
 
    //! @copydoc ::boost::intrusive::hashtable::find(const KeyType &,KeyHasher,KeyEqual)const
@@ -872,6 +879,7 @@ template<class T, class O1 = void, class O2 = void
                 , class O5 = void, class O6 = void
                 , class O7 = void, class O8 = void
                 , class O9 = void, class O10= void
+                , class O11 = void
                 >
 #endif
 struct make_unordered_multiset
@@ -880,7 +888,7 @@ struct make_unordered_multiset
    typedef typename pack_options
       < hashtable_defaults,
          #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
+         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11
          #else
          Options...
          #endif
@@ -890,7 +898,7 @@ struct make_unordered_multiset
       <T, typename packed_options::proto_value_traits>::type value_traits;
 
    typedef typename make_bucket_traits
-            <T, true, packed_options>::type bucket_traits;
+            <T, packed_options>::type bucket_traits;
 
    typedef unordered_multiset_impl
       < value_traits
@@ -905,6 +913,8 @@ struct make_unordered_multiset
       |  (std::size_t(packed_options::cache_begin)*hash_bool_flags::cache_begin_pos)
       |  (std::size_t(packed_options::compare_hash)*hash_bool_flags::compare_hash_pos)
       |  (std::size_t(packed_options::incremental)*hash_bool_flags::incremental_pos)
+      |  (std::size_t(packed_options::linear_buckets)*hash_bool_flags::linear_buckets_pos)
+      |  (std::size_t(packed_options::fastmod_buckets)*hash_bool_flags::fastmod_buckets_pos)
       > implementation_defined;
 
    /// @endcond
@@ -914,14 +924,14 @@ struct make_unordered_multiset
 #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10>
+template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10, class O11>
 #else
 template<class T, class ...Options>
 #endif
 class unordered_multiset
    :  public make_unordered_multiset<T,
          #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
+         O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11
          #else
          Options...
          #endif
@@ -936,7 +946,7 @@ class unordered_multiset
          #endif
       >::type   Base;
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_multiset)
 
    public:
@@ -949,7 +959,7 @@ class unordered_multiset
    typedef typename Base::hasher             hasher;
    typedef typename Base::key_equal          key_equal;
 
-   BOOST_INTRUSIVE_FORCEINLINE
+   inline
    explicit unordered_multiset( const bucket_traits &b_traits
                               , const hasher & hash_func = hasher()
                               , const key_equal &equal_func = key_equal()
@@ -958,7 +968,7 @@ class unordered_multiset
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE
+   inline
    unordered_multiset( Iterator b
                      , Iterator e
                      , const bucket_traits &b_traits
@@ -968,20 +978,20 @@ class unordered_multiset
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
+   inline unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+   inline 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>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
-   {  Base::clone_from(src, cloner, disposer);  }
+   inline void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
+   {  this->Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class 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);  }
+   inline void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
+   {  this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };
 
 #endif