passenger 5.1.4 → 5.1.5

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

@@ -141,7 +141,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void init_header(const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(const node_ptr & this_node)
    {  NodeTraits::set_next(this_node, node_ptr ());  }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list.
@@ -153,7 +153,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a linear list or be an empty linear list.

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

@@ -176,7 +176,20 @@ class list_impl
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks).
-   explicit list_impl(const value_traits &v_traits = value_traits())
+   list_impl()
+      :  data_(value_traits())
+   {
+      this->priv_size_traits().set_size(size_type(0));
+      node_algorithms::init_header(this->get_root_node());
+   }
+
+   //! <b>Effects</b>: constructs an empty list.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: If value_traits::node_traits::node
+   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks).
+   explicit list_impl(const value_traits &v_traits)
       :  data_(v_traits)
    {
       this->priv_size_traits().set_size(size_type(0));
@@ -529,11 +542,7 @@ class list_impl
    void swap(list_impl& other)
    {
       node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node());
-      if(constant_time_size){
-         size_type backup = this->priv_size_traits().get_size();
-         this->priv_size_traits().set_size(other.priv_size_traits().get_size());
-         other.priv_size_traits().set_size(backup);
-      }
+      this->priv_size_traits().swap(other.priv_size_traits());
    }
 
    //! <b>Effects</b>: Moves backwards all the elements, so that the first
@@ -1455,7 +1464,11 @@ class list
    typedef typename Base::iterator              iterator;
    typedef typename Base::const_iterator        const_iterator;
 
-   explicit list(const value_traits &v_traits = value_traits())
+   list()
+      :  Base()
+   {}
+
+   explicit list(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 

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

@@ -50,7 +50,8 @@ struct make_list_base_hook
       >::type packed_options;
 
    typedef generic_hook
-   < circular_list_algorithms<list_node_traits<typename packed_options::void_pointer> >
+   < CircularListAlgorithms
+   , list_node_traits<typename packed_options::void_pointer>
    , typename packed_options::tag
    , packed_options::link_mode
    , ListBaseHookId
@@ -177,7 +178,8 @@ struct make_list_member_hook
       >::type packed_options;
 
    typedef generic_hook
-   < circular_list_algorithms<list_node_traits<typename packed_options::void_pointer> >
+   < CircularListAlgorithms
+   , list_node_traits<typename packed_options::void_pointer>
    , member_tag
    , packed_options::link_mode
    , NoBaseHookId

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

@@ -18,6 +18,7 @@
 
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/parent_from_member.hpp>
+#include <boost/intrusive/detail/to_raw_pointer.hpp> 
 #include <boost/intrusive/pointer_traits.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -56,19 +57,19 @@ struct member_value_traits
    typedef const value_type &                                           const_reference;
    static const link_mode_type link_mode = LinkMode;
 
-   static node_ptr to_node_ptr(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
    {  return pointer_traits<node_ptr>::pointer_to(value.*PtrToMember);   }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
    {  return pointer_traits<const_node_ptr>::pointer_to(value.*PtrToMember);   }
 
-   static pointer to_value_ptr(const node_ptr &n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr &n)
    {
       return pointer_traits<pointer>::pointer_to(*detail::parent_from_member<value_type, node>
          (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
    }
 
-   static const_pointer to_value_ptr(const const_node_ptr &n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr &n)
    {
       return pointer_traits<const_pointer>::pointer_to(*detail::parent_from_member<value_type, node>
          (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));

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

@@ -61,12 +61,12 @@ BOOST_INTRUSIVE_OPTION_TYPE(size_type, SizeType, SizeType, size_type)
 //!comparison functor for the value type
 BOOST_INTRUSIVE_OPTION_TYPE(compare, Compare, Compare, compare)
 
-//!This option setter specifies the a function object
+//!This option setter specifies a function object
 //!that specifies the type of the key of an associative
 //!container and an operator to obtain it from a value type.
 //!
-//!This function object must the define a `key_type` and
-//!a member with signature `const key_type & operator()(const value_type &) const`
+//!This function object must the define a `type` member typedef and
+//!a member with signature `type [const&] operator()(const value_type &) const`
 //!that will return the key from a value_type of an associative container
 BOOST_INTRUSIVE_OPTION_TYPE(key_of_value, KeyOfValue, KeyOfValue, key_of_value)
 
@@ -88,7 +88,7 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(floating_point, bool, Enabled, floating_point)
 //!functor for the value type
 BOOST_INTRUSIVE_OPTION_TYPE(equal, Equal, Equal, equal)
 
-//!This option setter specifies the equality
+//!This option setter specifies the priority comparison
 //!functor for the value type
 BOOST_INTRUSIVE_OPTION_TYPE(priority, Priority, Priority, priority)
 

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

@@ -13,6 +13,7 @@
 #define BOOST_INTRUSIVE_PARENT_FROM_MEMBER_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 
 #include <boost/intrusive/detail/parent_from_member.hpp>
@@ -29,7 +30,7 @@ namespace intrusive {
 //! Note: this function does not work with pointer to members that rely on
 //! virtual inheritance.
 template<class Parent, class Member>
-inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member)
+BOOST_INTRUSIVE_FORCEINLINE Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member)
 {  return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member);  }
 
 //! Given a const pointer to a member and its corresponding const pointer to data member,
@@ -37,7 +38,7 @@ inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr
 //! Note: this function does not work with pointer to members that rely on
 //! virtual inheritance.
 template<class Parent, class Member>
-inline const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
+BOOST_INTRUSIVE_FORCEINLINE const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
 {  return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member);  }
 
 }  //namespace intrusive {

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

@@ -67,19 +67,19 @@ struct pointer_plus_bits<T*, NumBits>
    static const uintptr_t Mask = uintptr_t((uintptr_t(1u) << NumBits) - 1);
    typedef T*        pointer;
 
-   static pointer get_pointer(pointer n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer get_pointer(pointer n)
    {  return pointer(uintptr_t(n) & uintptr_t(~Mask));  }
 
-   static void set_pointer(pointer &n, pointer p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_pointer(pointer &n, pointer p)
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(0 == (uintptr_t(p) & Mask));
       n = pointer(uintptr_t(p) | (uintptr_t(n) & Mask));
    }
 
-   static std::size_t get_bits(pointer n)
+   BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_bits(pointer n)
    {  return std::size_t(uintptr_t(n) & Mask);  }
 
-   static void set_bits(pointer &n, std::size_t c)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_bits(pointer &n, std::size_t c)
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(uintptr_t(c) <= Mask);
       n = pointer(uintptr_t((get_pointer)(n)) | uintptr_t(c));

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

@@ -288,25 +288,25 @@ struct pointer_traits<T*>
 
    //! <b>Returns</b>: addressof(r)
    //!
-   static pointer pointer_to(reference r)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r)
    { return boost::intrusive::detail::addressof(r); }
 
    //! <b>Returns</b>: static_cast<pointer>(uptr)
    //!
    template<class U>
-   static pointer static_cast_from(U *uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr)
    {  return static_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: const_cast<pointer>(uptr)
    //!
    template<class U>
-   static pointer const_cast_from(U *uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr)
    {  return const_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
    //!
    template<class U>
-   static pointer dynamic_cast_from(U *uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr)
    {  return dynamic_cast<pointer>(uptr);  }
 };
 

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

@@ -14,6 +14,7 @@
 #define BOOST_INTRUSIVE_PRIORITY_COMPARE_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
@@ -25,7 +26,14 @@
 namespace boost {
 namespace intrusive {
 
-template <class T>
+/// @cond
+
+template<class U>
+void priority_order();
+
+/// @endcond
+
+template <class T = void>
 struct priority_compare
 {
    //Compatibility with std::binary_function
@@ -33,18 +41,28 @@ struct priority_compare
    typedef T      second_argument_type;
    typedef bool   result_type;
 
-   bool operator()(const T &val, const T &val2) const
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &val, const T &val2) const
    {
       return priority_order(val, val2);
    }
 };
 
+template <>
+struct priority_compare<void>
+{
+   template<class T, class U>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &t, const U &u) const
+   {
+      return priority_order(t, u);
+   }
+};
+
 /// @cond
 
-template<class Less, class T>
+template<class PrioComp, class T>
 struct get_prio
 {
-   typedef Less type;
+   typedef PrioComp type;
 };
 
 

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

@@ -121,9 +121,13 @@ class rbtree_impl
 
    typedef typename implementation_defined::insert_commit_data insert_commit_data;
 
+   //! @copydoc ::boost::intrusive::bstree::bstree()
+   rbtree_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
-   explicit rbtree_impl( const key_compare &cmp = key_compare()
-                       , const value_traits &v_traits = value_traits())
+   explicit rbtree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -184,6 +188,15 @@ class rbtree_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 rbtree_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -259,6 +272,14 @@ class rbtree_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);
 
@@ -418,6 +439,14 @@ class rbtree_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(rbtree<T, Options2...> &);
+
+   //! @copydoc ::boost::intrusive::bstree::merge_equal(bstree<T, Options2...>&)
+   template<class T, class ...Options2>
+   void merge_equal(rbtree<T, Options2...> &);
+
    friend bool operator< (const rbtree_impl &x, const rbtree_impl &y);
 
    friend bool operator==(const rbtree_impl &x, const rbtree_impl &y);
@@ -509,8 +538,11 @@ class rbtree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   explicit rbtree( const key_compare &cmp = key_compare()
-                  , const value_traits &v_traits = value_traits())
+   rbtree()
+      :  Base()
+   {}
+
+   explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 

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

@@ -284,20 +284,33 @@ class rbtree_algorithms
    {
       typename bstree_algo::data_for_rebalance info;
       bstree_algo::erase(header, z, info);
+      rebalance_after_erasure(header, z, info);
+      return z;
+   }
 
-      color new_z_color;
-      if(info.y != z){
-         new_z_color = NodeTraits::get_color(info.y);
-         NodeTraits::set_color(info.y, NodeTraits::get_color(z));
-      }
-      else{
-         new_z_color = NodeTraits::get_color(z);
-      }
-      //Rebalance rbtree if needed
-      if(new_z_color != NodeTraits::red()){
-         rebalance_after_erasure(header, info.x, info.x_parent);
+   //! @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 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)
@@ -431,7 +444,24 @@ class rbtree_algorithms
    /// @cond
    private:
 
-   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)
+   {
+      color new_z_color;
+      if(info.y != z){
+         new_z_color = NodeTraits::get_color(info.y);
+         NodeTraits::set_color(info.y, NodeTraits::get_color(z));
+      }
+      else{
+         new_z_color = NodeTraits::get_color(z);
+      }
+      //Rebalance rbtree if needed
+      if(new_z_color != NodeTraits::red()){
+         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)
    {
       while(1){
          if(x_parent == header || (x && NodeTraits::get_color(x) != NodeTraits::black())){

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

@@ -28,6 +28,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 multiset_impl;
+#endif
+
 //! The class template set is an intrusive container, that mimics most of
 //! the interface of std::set as described in the C++ standard.
 //!
@@ -83,9 +88,13 @@ class set_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::rbtree::rbtree()
+   set_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::rbtree::rbtree(const key_compare &,const value_traits &)
-   explicit set_impl( const key_compare &cmp = key_compare()
-                    , const value_traits &v_traits = value_traits())
+   explicit set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -146,6 +155,15 @@ class set_impl
    //! @copydoc ::boost::intrusive::rbtree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::rbtree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::rbtree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::rbtree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::rbtree::container_from_end_iterator(iterator)
    static set_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -196,6 +214,17 @@ class set_impl
    iterator insert(const_iterator hint, reference value)
    {  return tree_type::insert_unique(hint, value);  }
 
+   //! @copydoc ::boost::intrusive::rbtree::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::rbtree::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::rbtree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
    template<class KeyType, class KeyTypeKeyCompare>
    std::pair<iterator, bool> insert_check
@@ -384,6 +413,26 @@ class set_impl
 
    //! @copydoc ::boost::intrusive::rbtree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::rbtree::merge_unique
+   template<class ...Options2>
+   void merge(set<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::rbtree::merge_unique
+   template<class ...Options2>
+   void merge(multiset<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_unique(source);  }
+
+
+   template<class Compare2>
+   void merge(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 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 set( const key_compare &cmp = key_compare()
-               , const value_traits &v_traits = value_traits())
+   set()
+      :  Base()
+   {}
+
+   explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
@@ -573,9 +625,13 @@ class multiset_impl
    static const bool constant_time_size = tree_type::constant_time_size;
 
    public:
+   //! @copydoc ::boost::intrusive::rbtree::rbtree()
+   multiset_impl()
+      :  tree_type()
+   {}
+
    //! @copydoc ::boost::intrusive::rbtree::rbtree(const key_compare &,const value_traits &)
-   explicit multiset_impl( const key_compare &cmp = key_compare()
-                         , const value_traits &v_traits = value_traits())
+   explicit multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  tree_type(cmp, v_traits)
    {}
 
@@ -636,6 +692,15 @@ class multiset_impl
    //! @copydoc ::boost::intrusive::rbtree::crend()const
    const_reverse_iterator crend() const;
 
+   //! @copydoc ::boost::intrusive::rbtree::root()
+   iterator root();
+
+   //! @copydoc ::boost::intrusive::rbtree::root()const
+   const_iterator root() const;
+
+   //! @copydoc ::boost::intrusive::rbtree::croot()const
+   const_iterator croot() const;
+
    //! @copydoc ::boost::intrusive::rbtree::container_from_end_iterator(iterator)
    static multiset_impl &container_from_end_iterator(iterator end_iterator);
 
@@ -843,6 +908,25 @@ class multiset_impl
 
    //! @copydoc ::boost::intrusive::rbtree::remove_node
    void remove_node(reference value);
+
+   //! @copydoc ::boost::intrusive::rbtree::merge_equal
+   template<class ...Options2>
+   void merge(multiset<T, Options2...> &source);
+
+   //! @copydoc ::boost::intrusive::rbtree::merge_equal
+   template<class ...Options2>
+   void merge(set<T, Options2...> &source);
+
+   #else
+
+   template<class Compare2>
+   void merge(multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
+   {  return tree_type::merge_equal(source);  }
+
+   template<class Compare2>
+   void merge(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 multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   multiset( const key_compare &cmp = key_compare()
-           , const value_traits &v_traits = value_traits())
+   multiset()
+      :  Base()
+   {}
+
+   explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}