passenger 6.2.1 → 6.2.2

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

@@ -29,137 +29,9 @@ namespace boost {
 namespace intrusive {
 namespace detail {
 
-#if defined(BOOST_MSVC) || defined(__BORLANDC_)
-#define BOOST_INTRUSIVE_TT_DECL __cdecl
-#else
-#define BOOST_INTRUSIVE_TT_DECL
-#endif
-
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
-#define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-#endif
-
-template <typename T>
-struct is_unary_or_binary_function_impl
-{  static const bool value = false; };
-
-// see boost ticket #4094
-// avoid duplicate definitions of is_unary_or_binary_function_impl
-#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (*)()>
-{  static const bool value = true;  };
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (*)(...)>
-{  static const bool value = true;  };
-
-#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (__stdcall*)()>
-{  static const bool value = true;  };
-
-#ifndef _MANAGED
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (__fastcall*)()>
-{  static const bool value = true;  };
-
-#endif
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (__cdecl*)()>
-{  static const bool value = true;  };
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(...)>
-{  static const bool value = true;  };
-
-#endif
-
-// see boost ticket #4094
-// avoid duplicate definitions of is_unary_or_binary_function_impl
-#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (*)(T0)>
-{  static const bool value = true;  };
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (*)(T0, ...)>
-{  static const bool value = true;  };
-
-#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)>
-{  static const bool value = true;  };
-
-#ifndef _MANAGED
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)>
-{  static const bool value = true;  };
-
-#endif
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)>
-{  static const bool value = true;  };
-
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, ...)>
-{  static const bool value = true;  };
-
-#endif
-
-// see boost ticket #4094
-// avoid duplicate definitions of is_unary_or_binary_function_impl
-#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
-{  static const bool value = true;  };
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (*)(T0, T1, ...)>
-{  static const bool value = true;  };
-
-#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
-{  static const bool value = true;  };
-
-#ifndef _MANAGED
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)>
-{  static const bool value = true;  };
-
-#endif
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
-{  static const bool value = true;  };
-
-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1, ...)>
-{  static const bool value = true;  };
-#endif
-
-template <typename T>
-struct is_unary_or_binary_function_impl<T&>
-{  static const bool value = false; };
-
-template<typename T>
-struct is_unary_or_binary_function : is_unary_or_binary_function_impl<T>
-{};
-
-template<typename T, typename Tag = void, bool = is_unary_or_binary_function<T>::value>
+template<typename T, typename Tag = void>
 class ebo_functor_holder
+   :  public T
 {
    BOOST_COPYABLE_AND_MOVABLE(ebo_functor_holder)
 
@@ -167,33 +39,34 @@ class ebo_functor_holder
    typedef T functor_type;
 
    inline ebo_functor_holder()
-      : t_()
+      : T()
    {}
 
    inline explicit ebo_functor_holder(const T &t)
-      : t_(t)
+      : T(t)
    {}
 
    inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
-      : t_(::boost::move(t))
+      : T(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
    inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
-      : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
+      : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
    inline ebo_functor_holder(const ebo_functor_holder &x)
-      : t_(x.t_)
+      : T(static_cast<const T&>(x))
    {}
 
    inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
-      : t_(x.t_)
+      : T(BOOST_MOVE_BASE(T, x))
    {}
 
    inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
-      this->get() = x.get();
+      const ebo_functor_holder&r = x;
+      this->get() = r;
       return *this;
    }
 
@@ -203,28 +76,24 @@ class ebo_functor_holder
       return *this;
    }
 
-   inline ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(const T &t)
    {
-      this->get() = x;
+      this->get() = t;
       return *this;
    }
 
-   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) t)
    {
-      this->get() = ::boost::move(x);
+      this->get() = ::boost::move(t);
       return *this;
    }
 
-   inline T&       get(){return t_;}
-   inline const T& get()const{return t_;}
-
-   private:
-   T t_;
+   inline T&       get(){return *this;}
+   inline const T& get()const{return *this;}
 };
 
 template<typename T, typename Tag>
-class ebo_functor_holder<T, Tag, false>
-   :  public T
+class ebo_functor_holder<T *, Tag>
 {
    BOOST_COPYABLE_AND_MOVABLE(ebo_functor_holder)
 
@@ -232,57 +101,43 @@ class ebo_functor_holder<T, Tag, false>
    typedef T functor_type;
 
    inline ebo_functor_holder()
-      : T()
-   {}
-
-   inline explicit ebo_functor_holder(const T &t)
-      : T(t)
-   {}
-
-   inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
-      : T(::boost::move(t))
+      : t_()
    {}
 
-   template<class Arg1, class Arg2>
-   inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
-      : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
+   inline explicit ebo_functor_holder(T * t)
+      : t_(t)
    {}
 
    inline ebo_functor_holder(const ebo_functor_holder &x)
-      : T(static_cast<const T&>(x))
+      : t_(x.t_)
    {}
 
    inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
-      : T(BOOST_MOVE_BASE(T, x))
+      : t_(x.t_)
    {}
 
    inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
-      const ebo_functor_holder&r = x;
-      this->get() = r;
+      this->t_ = x.t_;
       return *this;
    }
 
    inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
-      this->get() = ::boost::move(x.get());
+      this->t_ = ::boost::move(x.t_);
       return *this;
    }
 
-   inline ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(T * t)
    {
-      this->get() = x;
+      this->t_ = t;
       return *this;
    }
 
-   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
-   {
-      this->get() = ::boost::move(x);
-      return *this;
-   }
+   inline T&       get(){return *t_;}
 
-   inline T&       get(){return *this;}
-   inline const T& get()const{return *this;}
+   private:
+   T * t_;
 };
 
 }  //namespace detail {

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

@@ -170,15 +170,23 @@ class generic_hook
    /// @endcond
 
    inline generic_hook() BOOST_NOEXCEPT
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (LinkMode != normal_link)
+   #endif
    {
-      if(hooktags::safemode_or_autounlink){
+      BOOST_IF_CONSTEXPR(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   generic_hook() requires (LinkMode == normal_link) = default;
+   #endif
+
    inline generic_hook(const generic_hook& ) BOOST_NOEXCEPT
    {
-      if(hooktags::safemode_or_autounlink){
+      BOOST_IF_CONSTEXPR(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
@@ -187,11 +195,19 @@ class generic_hook
    {  return *this;  }
 
    inline ~generic_hook()
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (LinkMode != normal_link)
+   #endif
    {
       destructor_impl
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   ~generic_hook() requires (LinkMode == normal_link) = default;
+   #endif
+
    inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes

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

@@ -22,7 +22,6 @@
 #endif
 
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/ebo_functor_holder.hpp>
 #include <boost/intrusive/detail/tree_value_compare.hpp>
 
 

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

@@ -48,11 +48,7 @@
 #elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
    //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_INTRUSIVE_FORCEINLINE inline
-#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
-   //Older GCCs have problems with forceinline
-   //Clang can have code bloat issues with forceinline, see
-   //https://lists.boost.org/boost-users/2023/04/91445.php and
-   //https://github.com/llvm/llvm-project/issues/62202
+#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
    #define BOOST_INTRUSIVE_FORCEINLINE inline
 #else
    #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
@@ -121,5 +117,8 @@ template<unsigned> struct static_assert_test {};
 #  define BOOST_INTRUSIVE_NO_DANGLING
 #endif
 
+#if defined(__cpp_concepts) && (__cpp_concepts >= 202002L)
+#  define BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING
+#endif
 
 #endif   //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP

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

@@ -1909,7 +1909,19 @@ struct hashdata_internal
    {  return this->priv_size_traits();  }
 
    ~hashdata_internal()
-   {  this->priv_clear_buckets();  }
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (ValueTraits::link_mode != normal_link)
+   #endif
+   {
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink){
+         this->priv_clear_buckets();
+      }
+   }
+
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   ~hashdata_internal() requires (ValueTraits::link_mode == normal_link) = default;
+   #endif
 
    using split_bucket_hash_equal_t::priv_clear_buckets;
 
@@ -1976,11 +1988,8 @@ struct hashdata_internal
       else {
          BOOST_IF_CONSTEXPR(incremental) {
             BOOST_ASSERT(0 == (std::size_t(bc) & (std::size_t(bc) - 1u)));
-            return bc;
-         }
-         else{         
-            return bc;
          }
+         return bc;
       }
    }
 
@@ -2462,6 +2471,7 @@ class hashtable_impl
    hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x)
    {  this->swap(x); return *this;  }
 
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
    //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set
    //!   are not deleted (i.e. no destructors are called).
    //!
@@ -2469,10 +2479,8 @@ class hashtable_impl
    //!   it's a safe-mode or auto-unlink value. Otherwise constant.
    //!
    //! <b>Throws</b>: Nothing.
-   ~hashtable_impl()
-   {}
+   ~hashtable_impl();
 
-   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
    //! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_set.
    //!
    //! <b>Complexity</b>: Amortized constant time.
@@ -2548,7 +2556,7 @@ class hashtable_impl
       BOOST_IF_CONSTEXPR(constant_time_size){
          return !this->size();
       }
-      else if(cache_begin){
+      else BOOST_IF_CONSTEXPR(cache_begin){
          return this->begin() == this->end();
       }
       else{
@@ -3066,7 +3074,7 @@ class hashtable_impl
 
       std::size_t cnt(0);
       if(success){
-         if(optimize_multikey){
+         BOOST_IF_CONSTEXPR(optimize_multikey){
             siterator past_last_in_group = it;
             (priv_go_to_last_in_group)(past_last_in_group, optimize_multikey_t());
             ++past_last_in_group;
@@ -3741,7 +3749,8 @@ class hashtable_impl
    friend bool operator==(const hashtable_impl &x, const hashtable_impl &y)
    {
       //Taken from N3068
-      if(constant_time_size && x.size() != y.size()){
+      BOOST_IF_CONSTEXPR(constant_time_size)
+      if(x.size() != y.size()){
          return false;
       }
 

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

@@ -249,6 +249,9 @@ class list_impl
    //! <b>Complexity</b>: Linear to the number of elements in the list, if
    //!   it's a safe-mode or auto-unlink value . Otherwise constant.
    ~list_impl()
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (ValueTraits::link_mode != normal_link)
+   #endif
    {
       BOOST_IF_CONSTEXPR(is_safe_autounlink<ValueTraits::link_mode>::value){
          this->clear();
@@ -256,6 +259,11 @@ class list_impl
       }
    }
 
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   ~list_impl() requires (ValueTraits::link_mode == normal_link) = default;
+   #endif
+
    //! <b>Requires</b>: value must be an lvalue.
    //!
    //! <b>Effects</b>: Inserts the value in the back of the list.
@@ -1118,13 +1126,15 @@ class list_impl
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
-   void remove(const_reference value) BOOST_NOEXCEPT
-   {  this->remove_if(detail::equal_to_value<const_reference>(value));  }
+   size_type remove(const_reference value) BOOST_NOEXCEPT
+   {  return this->remove_if(detail::equal_to_value<const_reference>(value));  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!   Disposer::operator()(pointer) is called for every removed element.
+   //! 
+   //! <b>Returns</b>: The number of erased elements.
    //!
    //! <b>Throws</b>: If operator == throws. Basic guarantee.
    //!
@@ -1133,12 +1143,14 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
-   void remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
-   {  this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
+   size_type remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
+   {  return this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied. No destructors are called.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If pred throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() calls to the predicate.
@@ -1146,7 +1158,7 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Pred>
-   void remove_if(Pred pred)
+   size_type remove_if(Pred pred)
    {
       const node_ptr root_node = this->get_root_node();
       typename node_algorithms::stable_partition_info info;
@@ -1157,6 +1169,7 @@ class list_impl
       this->erase( const_iterator(node_traits::get_next(root_node), this->priv_value_traits_ptr())
                  , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                  , info.num_1st_partition);
+      return info.num_1st_partition;
    }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1165,6 +1178,8 @@ class list_impl
    //!   predicate is satisfied.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If pred throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
@@ -1172,7 +1187,7 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Pred, class Disposer>
-   void remove_and_dispose_if(Pred pred, Disposer disposer)
+   size_type remove_and_dispose_if(Pred pred, Disposer disposer)
    {
       const node_ptr root_node = this->get_root_node();
       typename node_algorithms::stable_partition_info info;
@@ -1183,24 +1198,29 @@ class list_impl
       this->erase_and_dispose( const_iterator(node_traits::get_next(root_node), this->priv_value_traits_ptr())
                              , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                              , disposer);
+      return info.num_1st_partition;
    }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list. No destructors are called.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If the comparison operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()).
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
-   void unique()
-   {  this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
+   size_type unique()
+   {  return this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
    //!   No destructors are called.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If pred throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons equality comparisons).
@@ -1208,8 +1228,8 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class BinaryPredicate>
-   void unique(BinaryPredicate pred)
-   {  this->unique_and_dispose(pred, detail::null_disposer());  }
+   size_type unique(BinaryPredicate pred)
+   {  return this->unique_and_dispose(pred, detail::null_disposer());  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1217,6 +1237,8 @@ class list_impl
    //!   elements that are equal from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If the equality operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
@@ -1224,8 +1246,8 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
-   void unique_and_dispose(Disposer disposer)
-   {  this->unique_and_dispose(value_equal<value_type>(), disposer);  }
+   size_type unique_and_dispose(Disposer disposer)
+   {  return this->unique_and_dispose(value_equal<value_type>(), disposer);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1233,6 +1255,8 @@ class list_impl
    //!   elements that satisfy some binary predicate from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If pred throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
@@ -1240,10 +1264,11 @@ class list_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class BinaryPredicate, class Disposer>
-   void unique_and_dispose(BinaryPredicate pred, Disposer disposer)
+   size_type unique_and_dispose(BinaryPredicate pred, Disposer disposer)
    {
       const_iterator itend(this->cend());
       const_iterator cur(this->cbegin());
+      size_type n = 0;
 
       if(cur != itend){
          const_iterator after(cur);
@@ -1251,6 +1276,7 @@ class list_impl
          while(after != itend){
             if(pred(*cur, *after)){
                after = this->erase_and_dispose(after, disposer);
+               ++n;
             }
             else{
                cur = after;
@@ -1258,6 +1284,7 @@ class list_impl
             }
          }
       }
+      return n;
    }
 
    //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
@@ -1366,7 +1393,8 @@ class list_impl
 
    friend bool operator==(const list_impl &x, const list_impl &y)
    {
-      if(constant_time_size && x.size() != y.size()){
+      BOOST_IF_CONSTEXPR(constant_time_size)
+      if(x.size() != y.size()){
          return false;
       }
       return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());