passenger 6.0.14 → 6.0.27

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

@@ -0,0 +1,130 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2022 Peter Dimov
+// Copyright 2024 Ion Gaztanaga
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// The original C++11 implementation was done by Peter Dimov
+// The C++03 porting was done by Ion Gaztanaga
+// 
+// Refactored the original Boost ContainerHash library to avoid
+// any heavy std header dependencies to just mix a hash
+// value represented in a std::size_t type.
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef BOOST_INTRUSIVE_DETAIL_HASH_MIX_HPP
+#define BOOST_INTRUSIVE_DETAIL_HASH_MIX_HPP
+
+#include <boost/cstdint.hpp>      //boost::uint64_t
+#include <cstddef>
+#include <climits>
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+   
+
+template<std::size_t Bits> struct hash_mix_impl;
+
+// hash_mix for 64 bit size_t
+//
+// The general "xmxmx" form of state of the art 64 bit mixers originates
+// from Murmur3 by Austin Appleby, which uses the following function as
+// its "final mix":
+//
+// k ^= k >> 33;
+// k *= 0xff51afd7ed558ccd;
+// k ^= k >> 33;
+// k *= 0xc4ceb9fe1a85ec53;
+// k ^= k >> 33;
+//
+// (https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
+//
+// It has subsequently been improved multiple times by different authors
+// by changing the constants. The most well known improvement is the
+// so-called "variant 13" function by David Stafford:
+//
+// k ^= k >> 30;
+//	k *= 0xbf58476d1ce4e5b9;
+//	k ^= k >> 27;
+//	k *= 0x94d049bb133111eb;
+//	k ^= k >> 31;
+//
+// (https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html)
+//
+// This mixing function is used in the splitmix64 RNG:
+// http://xorshift.di.unimi.it/splitmix64.c
+//
+// We use Jon Maiga's implementation from
+// http://jonkagstrom.com/mx3/mx3_rev2.html
+//
+// x ^= x >> 32;
+//	x *= 0xe9846af9b1a615d;
+//	x ^= x >> 32;
+//	x *= 0xe9846af9b1a615d;
+//	x ^= x >> 28;
+//
+// An equally good alternative is Pelle Evensen's Moremur:
+//
+//	x ^= x >> 27;
+//	x *= 0x3C79AC492BA7B653;
+//	x ^= x >> 33;
+//	x *= 0x1C69B3F74AC4AE35;
+//	x ^= x >> 27;
+//
+// (https://mostlymangling.blogspot.com/2019/12/stronger-better-morer-moremur-better.html)
+
+template<> struct hash_mix_impl<64>
+{
+    inline static boost::uint64_t fn( boost::uint64_t x )
+    {
+        boost::uint64_t const m = 0xe9846af9b1a615d;
+
+        x ^= x >> 32;
+        x *= m;
+        x ^= x >> 32;
+        x *= m;
+        x ^= x >> 28;
+
+        return x;
+    }
+};
+
+// hash_mix for 32 bit size_t
+//
+// We use the "best xmxmx" implementation from
+// https://github.com/skeeto/hash-prospector/issues/19
+
+template<> struct hash_mix_impl<32>
+{
+    inline static boost::uint32_t fn( boost::uint32_t x )
+    {
+        boost::uint32_t const m1 = 0x21f0aaad;
+        boost::uint32_t const m2 = 0x735a2d97;
+
+        x ^= x >> 16;
+        x *= m1;
+        x ^= x >> 15;
+        x *= m2;
+        x ^= x >> 15;
+
+        return x;
+    }
+};
+
+inline std::size_t hash_mix( std::size_t v )
+{
+    return hash_mix_impl<sizeof(std::size_t) * CHAR_BIT>::fn( v );
+}
+
+
+} // namespace detail
+} // namespace intrusive
+} // namespace boost
+
+#endif // #ifndef BOOST_INTRUSIVE_DETAIL_HASH_MIX_HPP

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

@@ -26,7 +26,10 @@
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/trivial_value_traits.hpp>
-#include <boost/intrusive/slist.hpp> //make_slist
+#include <boost/intrusive/detail/common_slist_algorithms.hpp>
+#include <boost/intrusive/detail/iiterator.hpp>
+#include <boost/intrusive/detail/slist_iterator.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <cstddef>
 #include <climits>
 #include <boost/move/core.hpp>
@@ -35,79 +38,43 @@
 namespace boost {
 namespace intrusive {
 
-template <class Slist>
-struct bucket_impl : public Slist
+template <class NodeTraits>
+struct bucket_impl
+   : public NodeTraits::node
 {
-   typedef Slist slist_type;
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
-   {}
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
-   {}
-
-   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
-   {
-      //This bucket is still being used!
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-   }
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
-   {
-      //This bucket is still in use!
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-      return *this;
-   }
-};
+   public:
+   typedef NodeTraits node_traits;
 
-template<class Slist>
-struct bucket_traits_impl
-{
    private:
-   BOOST_COPYABLE_AND_MOVABLE(bucket_traits_impl)
+   typedef typename node_traits::node_ptr          node_ptr;
+   typedef typename node_traits::const_node_ptr    const_node_ptr;
+
+   typedef detail::common_slist_algorithms<NodeTraits> algo_t;
 
    public:
-   /// @cond
+   inline bucket_impl()
+   {}
 
-   typedef typename pointer_traits
-      <typename Slist::pointer>::template rebind_pointer
-         < bucket_impl<Slist> >::type                                bucket_ptr;
-   typedef Slist slist;
-   typedef typename Slist::size_type size_type;
-   /// @endcond
-
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(bucket_ptr buckets, size_type len)
-      :  buckets_(buckets), buckets_len_(len)
+   inline bucket_impl(const bucket_impl &)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(const bucket_traits_impl &x)
-      : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
+   inline ~bucket_impl()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
-      : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
-   {  x.buckets_ = bucket_ptr();   x.buckets_len_ = 0;  }
+   inline bucket_impl &operator=(const bucket_impl&)
+   {  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
-   {
-      buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
-      x.buckets_ = bucket_ptr();   x.buckets_len_ = 0; return *this;
-   }
+   inline node_ptr get_node_ptr()
+   {  return pointer_traits<node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
-   {
-      buckets_ = x.buckets_;  buckets_len_ = x.buckets_len_; return *this;
-   }
+   inline const_node_ptr get_node_ptr() const
+   {  return pointer_traits<const_node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const bucket_ptr &bucket_begin() const
-   {  return buckets_;  }
+   inline node_ptr begin_ptr()
+   {  return node_traits::get_next(get_node_ptr());  }
+};
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type  bucket_count() const BOOST_NOEXCEPT
-   {  return buckets_len_;  }
 
-   private:
-   bucket_ptr  buckets_;
-   size_type   buckets_len_;
-};
 
 template <class NodeTraits>
 struct hash_reduced_slist_node_traits
@@ -133,22 +100,7 @@ struct reduced_slist_node_traits
       >::type type;
 };
 
-template<class NodeTraits>
-struct get_slist_impl
-{
-   typedef trivial_value_traits<NodeTraits, normal_link> trivial_traits;
-
-   //Reducing symbol length
-   struct type : make_slist
-      < typename NodeTraits::node
-      , boost::intrusive::value_traits<trivial_traits>
-      , boost::intrusive::constant_time_size<false>
-      , boost::intrusive::size_type<std::size_t>
-      >::type
-   {};
-};
-
-template<class BucketValueTraits, bool IsConst>
+template<class BucketValueTraits, bool LinearBuckets, bool IsConst>
 class hashtable_iterator
 {
    typedef typename BucketValueTraits::value_traits            value_traits;
@@ -166,24 +118,25 @@ class hashtable_iterator
    private:
    typedef typename value_traits::node_traits                  node_traits;
    typedef typename node_traits::node_ptr                      node_ptr;
-   typedef typename get_slist_impl
-      < typename reduced_slist_node_traits
-         <node_traits>::type >::type                           slist_impl;
-   typedef typename slist_impl::iterator                       siterator;
-   typedef typename slist_impl::const_iterator                 const_siterator;
-   typedef bucket_impl<slist_impl>                             bucket_type;
+   typedef typename BucketValueTraits::bucket_type             bucket_type;
+   typedef typename bucket_type::node_traits                   slist_node_traits;
+   typedef typename slist_node_traits::node_ptr                slist_node_ptr;
+   typedef trivial_value_traits
+      <slist_node_traits, normal_link>                         slist_value_traits;
+   typedef slist_iterator<slist_value_traits, false>           siterator;
+   typedef slist_iterator<slist_value_traits, true>            const_siterator;
+   typedef circular_slist_algorithms<slist_node_traits>        slist_node_algorithms;
 
    typedef typename pointer_traits
       <pointer>::template rebind_pointer
          < const BucketValueTraits >::type                     const_bucketvaltraits_ptr;
-   typedef typename slist_impl::size_type                      size_type;
    class nat;
    typedef typename
       detail::if_c< IsConst
-                  , hashtable_iterator<BucketValueTraits, false>
+                  , hashtable_iterator<BucketValueTraits, LinearBuckets, false>
                   , nat>::type                                 nonconst_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
+   inline static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -191,94 +144,93 @@ class hashtable_iterator
 
    public:
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator ()
+   inline hashtable_iterator ()
       : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont)
+   inline explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont)
       : slist_it_ (ptr)
       , traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() )
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other)
+   inline hashtable_iterator(const hashtable_iterator &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other)
+   inline hashtable_iterator(const nonconst_iterator &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
+   inline const siterator &slist_it() const
    { return slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, false> unconst() const
-   {  return hashtable_iterator<BucketValueTraits, false>(this->slist_it(), this->get_bucket_value_traits());   }
+   inline hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const
+   {  return hashtable_iterator<BucketValueTraits, LinearBuckets, false>(this->slist_it(), this->get_bucket_value_traits());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
+   inline hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other)
+   inline hashtable_iterator &operator=(const hashtable_iterator &other)
    {  slist_it_ = other.slist_it(); traitsptr_ = other.get_bucket_value_traits();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int)
+   inline hashtable_iterator operator++(int)
    {
       hashtable_iterator result (*this);
       this->increment();
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return i.slist_it_ == i2.slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    { return *this->operator ->(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    {
       return this->priv_value_traits().to_value_ptr
          (downcast_bucket(slist_it_.pointed_node()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE const const_bucketvaltraits_ptr &get_bucket_value_traits() const
+   inline const_bucketvaltraits_ptr get_bucket_value_traits() const
    {  return traitsptr_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
+   inline const value_traits &priv_value_traits() const
    {  return traitsptr_->priv_value_traits();  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const bucket_traits &priv_bucket_traits() const
-   {  return traitsptr_->priv_bucket_traits();  }
-
    private:
+
    void increment()
    {
-      const bucket_traits &rbuck_traits = this->priv_bucket_traits();
-      bucket_type* const buckets = boost::movelib::to_raw_pointer(rbuck_traits.bucket_begin());
-      const size_type buckets_len = rbuck_traits.bucket_count();
+      bucket_type* const buckets = boost::movelib::to_raw_pointer(traitsptr_->priv_bucket_traits().bucket_begin());
+      const std::size_t buckets_len = traitsptr_->priv_bucket_traits().bucket_count();
 
       ++slist_it_;
-      const typename slist_impl::node_ptr n = slist_it_.pointed_node();
-      const siterator first_bucket_bbegin = buckets->end();
-      if(first_bucket_bbegin.pointed_node() <= n && n <= buckets[buckets_len-1].cend().pointed_node()){
+      const slist_node_ptr n = slist_it_.pointed_node();
+      const siterator first_bucket_bbegin(buckets->get_node_ptr());
+      if(first_bucket_bbegin.pointed_node() <= n && n <= buckets[buckets_len-1].get_node_ptr()){
          //If one-past the node is inside the bucket then look for the next non-empty bucket
          //1. get the bucket_impl from the iterator
-         const bucket_type &b = static_cast<const bucket_type&>
-            (bucket_type::slist_type::container_from_end_iterator(slist_it_));
+         const bucket_type &b = static_cast<const bucket_type&>(*n);
 
          //2. Now just calculate the index b has in the bucket array
-         size_type n_bucket = static_cast<size_type>(&b - buckets);
+         std::size_t n_bucket = static_cast<std::size_t>(&b - buckets);
 
          //3. Iterate until a non-empty bucket is found
+         slist_node_ptr bucket_nodeptr = buckets->get_node_ptr();
          do{
             if (++n_bucket >= buckets_len){  //bucket overflow, return end() iterator
-               slist_it_ = buckets->before_begin();
+               slist_it_ = first_bucket_bbegin;
                return;
             }
+            bucket_nodeptr = buckets[n_bucket].get_node_ptr();
          }
-         while (buckets[n_bucket].empty());
-         slist_it_ = buckets[n_bucket].begin();
+         while (slist_node_algorithms::is_empty(bucket_nodeptr));
+         slist_it_ = siterator(bucket_nodeptr);
+         ++slist_it_;
       }
       else{
          //++slist_it_ yield to a valid object
@@ -289,6 +241,134 @@ class hashtable_iterator
    const_bucketvaltraits_ptr  traitsptr_;
 };
 
+template<class BucketValueTraits, bool IsConst>
+class hashtable_iterator<BucketValueTraits, true, IsConst>
+{
+   typedef typename BucketValueTraits::value_traits            value_traits;
+   typedef typename BucketValueTraits::bucket_traits           bucket_traits;
+
+   typedef iiterator< value_traits, IsConst
+                    , std::forward_iterator_tag>   types_t;
+   public:
+   typedef typename types_t::iterator_type::difference_type    difference_type;
+   typedef typename types_t::iterator_type::value_type         value_type;
+   typedef typename types_t::iterator_type::pointer            pointer;
+   typedef typename types_t::iterator_type::reference          reference;
+   typedef typename types_t::iterator_type::iterator_category  iterator_category;
+
+   private:
+   typedef typename value_traits::node_traits                  node_traits;
+   typedef typename node_traits::node_ptr                      node_ptr;
+   typedef typename BucketValueTraits::bucket_type             bucket_type;
+   typedef typename BucketValueTraits::bucket_ptr              bucket_ptr;
+   typedef typename bucket_type::node_traits                   slist_node_traits;
+   typedef linear_slist_algorithms<slist_node_traits>          slist_node_algorithms;
+   typedef typename slist_node_traits::node_ptr                slist_node_ptr;
+   typedef trivial_value_traits
+      <slist_node_traits, normal_link>                         slist_value_traits;
+   typedef slist_iterator<slist_value_traits, false>           siterator;
+   typedef slist_iterator<slist_value_traits, true>            const_siterator;
+
+   static const bool stateful_value_traits =
+      detail::is_stateful_value_traits<value_traits>::value;
+
+   typedef typename pointer_traits
+      <pointer>::template rebind_pointer
+         < const value_traits >::type                          const_value_traits_ptr;
+   class nat;
+   typedef typename
+      detail::if_c< IsConst
+                  , hashtable_iterator<BucketValueTraits, true, false>
+                  , nat>::type                                 nonconst_iterator;
+
+   inline static node_ptr downcast_bucket(slist_node_ptr p)
+   {
+      return pointer_traits<node_ptr>::
+         pointer_to(static_cast<typename node_traits::node&>(*p));
+   }
+
+   public:
+
+   inline hashtable_iterator ()
+      : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
+      , members_()
+   {}
+
+   inline explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr)
+      : slist_it_ (ptr)
+      , members_ (bp, traits_ptr)
+   {}
+
+   inline hashtable_iterator(const hashtable_iterator &other)
+      :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
+   {}
+
+   inline hashtable_iterator(const nonconst_iterator &other)
+      :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
+   {}
+
+   inline const siterator &slist_it() const
+   { return slist_it_; }
+
+   inline hashtable_iterator<BucketValueTraits, true, false> unconst() const
+   {  return hashtable_iterator<BucketValueTraits, true, false>(this->slist_it(), members_.nodeptr_, members_.get_ptr());   }
+
+   inline hashtable_iterator& operator++()
+   {  this->increment();   return *this;   }
+
+   inline hashtable_iterator &operator=(const hashtable_iterator &other)
+   {  slist_it_ = other.slist_it(); members_ = other.members_;  return *this;  }
+
+   inline hashtable_iterator operator++(int)
+   {
+      hashtable_iterator result (*this);
+      this->increment();
+      return result;
+   }
+
+   inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   { return i.slist_it_ == i2.slist_it_; }
+
+   inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   { return i.slist_it_ != i2.slist_it_; }
+
+   inline reference operator*() const
+   { return *this->operator ->(); }
+
+   inline pointer operator->() const
+   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
+
+   inline const_value_traits_ptr get_value_traits() const
+   {  return members_.get_ptr(); }
+
+   inline bucket_ptr get_bucket_ptr() const
+   {  return members_.nodeptr_; }
+
+   private:
+
+   inline pointer operator_arrow(detail::false_) const
+   { return value_traits::to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
+
+   inline pointer operator_arrow(detail::true_) const
+   { return this->get_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
+
+   void increment()
+   {
+      ++slist_it_;
+      if (slist_it_ == siterator()){
+         slist_node_ptr bucket_nodeptr;
+         do {
+            ++members_.nodeptr_;
+             bucket_nodeptr = members_.nodeptr_->get_node_ptr();
+         }while(slist_node_algorithms::is_empty(bucket_nodeptr));
+         slist_it_ = siterator(slist_node_traits::get_next(bucket_nodeptr));
+      }
+   }
+
+   siterator   slist_it_;
+   iiterator_members<bucket_ptr, const_value_traits_ptr, stateful_value_traits> members_;
+};
+
 }  //namespace intrusive {
 }  //namespace boost {
 

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

@@ -46,8 +46,10 @@ struct bhtraits_base
       template rebind_pointer<T>::type                               pointer;
    typedef typename pointer_traits<node_ptr>::
       template rebind_pointer<const T>::type                         const_pointer;
-   //typedef typename pointer_traits<pointer>::reference               reference;
-   //typedef typename pointer_traits<const_pointer>::reference         const_reference;
+   typedef typename pointer_traits<node_ptr>::
+      template rebind_pointer<node_holder_type>::type                node_holder_ptr;
+   typedef typename pointer_traits<node_ptr>::
+      template rebind_pointer<const node_holder_type>::type          const_node_holder_ptr;
    typedef T &                                                       reference;
    typedef const T &                                                 const_reference;
    typedef node_holder_type &                                        node_holder_reference;
@@ -55,35 +57,29 @@ struct bhtraits_base
    typedef node&                                                     node_reference;
    typedef const node &                                              const_node_reference;
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
-      pointer p = pointer_traits<pointer>::pointer_to
-         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
-      return p;
+      return pointer_traits<pointer>::
+         static_cast_from(pointer_traits<node_holder_ptr>::static_cast_from(n));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
-      const_pointer p = pointer_traits<const_pointer>::pointer_to
-         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
-      return p;
+      return pointer_traits<const_pointer>::
+         static_cast_from(pointer_traits<const_node_holder_ptr>::static_cast_from(n));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       node_ptr p = pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 };
@@ -120,26 +116,26 @@ struct mhtraits
 
    static const link_mode_type link_mode = Hook::hooktags::link_mode;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       return pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       return pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
             (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
@@ -168,23 +164,23 @@ struct fhtraits
    typedef const value_type &                                        const_reference;
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
-   static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static pointer to_value_ptr(const node_ptr & n)
+   inline static pointer to_value_ptr(node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
-   static const_pointer to_value_ptr(const const_node_ptr & n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
    private:
-   static hook_ptr to_hook_ptr(const node_ptr & n)
+   inline static hook_ptr to_hook_ptr(node_ptr n)
    {  return hook_ptr(&*static_cast<hook_type*>(&*n));  }
 
-   static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
+   inline static const_hook_ptr to_hook_ptr(const_node_ptr n)
    {  return const_hook_ptr(&*static_cast<const hook_type*>(&*n));  }
 };