From 497ea883364de4f24d3c145034690f62fa63aa28 Mon Sep 17 00:00:00 2001
From: slymz <slymz@users.noreply.github.com>
Date: Tue, 27 Dec 2016 17:04:39 -0500
Subject: [PATCH 1/6] Update intrusive.qbk

Minor but subtle (for beginners) correction.
---
 doc/intrusive.qbk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/intrusive.qbk b/doc/intrusive.qbk
index 8e5b10c..22685c7 100644
--- a/doc/intrusive.qbk
+++ b/doc/intrusive.qbk
@@ -701,7 +701,7 @@ with the name of the file to include:
 
 These hooks have exactly the same size overhead as their analog non auto-unlinking
 hooks, but they have a restriction: they can only be used with
-[link intrusive.presenting_containers non-constant time containers].
+[link intrusive.presenting_containers non-constant time size containers].
 There is a reason for this:
 
 * Auto-unlink hooks don't store any reference to the container where they are inserted.

From 140613d1ba19d63ccad92086233d55d4f4749547 Mon Sep 17 00:00:00 2001
From: Andrey Semashev <Lastique@users.noreply.github.com>
Date: Tue, 4 Apr 2017 15:45:11 +0300
Subject: [PATCH 2/6] Fix a typo in the docs

---
 include/boost/intrusive/slist.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/intrusive/slist.hpp b/include/boost/intrusive/slist.hpp
index 0020699..f34350d 100644
--- a/include/boost/intrusive/slist.hpp
+++ b/include/boost/intrusive/slist.hpp
@@ -1115,7 +1115,7 @@ class slist_impl
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Lineal to the elements (l - before_f + 1).
+   //! <b>Complexity</b>: Linear to the elements (l - before_f + 1).
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>

From 9268e2a3d89ccac30e36bd979283b045547ef1d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <igaztanaga@gmail.com>
Date: Thu, 6 Apr 2017 23:32:15 +0200
Subject: [PATCH 3/6] Reuse utilities from Boost.Move

---
 .../intrusive/detail/pointer_element.hpp      | 140 +-----------------
 .../boost/intrusive/detail/to_raw_pointer.hpp |  11 +-
 2 files changed, 9 insertions(+), 142 deletions(-)

diff --git a/include/boost/intrusive/detail/pointer_element.hpp b/include/boost/intrusive/detail/pointer_element.hpp
index dd26e3c..235ecf4 100644
--- a/include/boost/intrusive/detail/pointer_element.hpp
+++ b/include/boost/intrusive/detail/pointer_element.hpp
@@ -23,146 +23,20 @@
 #include <boost/intrusive/detail/workaround.hpp>
 #endif   //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
 
+#include <boost/move/detail/pointer_element.hpp>
+
 namespace boost {
 namespace intrusive {
-namespace detail{
 
-//////////////////////
-//struct first_param
-//////////////////////
+using ::boost::movelib::pointer_element;
 
-template <typename T> struct first_param
-{  typedef void type;   };
+namespace detail {
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+using ::boost::movelib::detail::first_param;
 
-   template <template <typename, typename...> class TemplateClass, typename T, typename... Args>
-   struct first_param< TemplateClass<T, Args...> >
-   {
-      typedef T type;
-   };
+}
 
-#else //C++03 compilers
-
-   template < template  //0arg
-               <class
-               > class TemplateClass, class T
-            >
-   struct first_param
-      < TemplateClass<T> >
-   {  typedef T type;   };
-
-   template < template  //1arg
-               <class,class
-               > class TemplateClass, class T
-            , class P0>
-   struct first_param
-      < TemplateClass<T, P0> >
-   {  typedef T type;   };
-
-   template < template  //2arg
-               <class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1>
-   struct first_param
-      < TemplateClass<T, P0, P1> >
-   {  typedef T type;   };
-
-   template < template  //3arg
-               <class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2> >
-   {  typedef T type;   };
-
-   template < template  //4arg
-               <class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3> >
-   {  typedef T type;   };
-
-   template < template  //5arg
-               <class,class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3, class P4>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3, P4> >
-   {  typedef T type;   };
-
-   template < template  //6arg
-               <class,class,class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3, class P4, class P5>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3, P4, P5> >
-   {  typedef T type;   };
-
-   template < template  //7arg
-               <class,class,class,class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3, class P4, class P5, class P6>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6> >
-   {  typedef T type;   };
-
-   template < template  //8arg
-               <class,class,class,class,class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7> >
-   {  typedef T type;   };
-
-   template < template  //9arg
-               <class,class,class,class,class,class,class,class,class,class
-               > class TemplateClass, class T
-            , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
-   struct first_param
-      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8> >
-   {  typedef T type;   };
-
-#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-template <typename T>
-struct has_internal_pointer_element
-{
-   template <typename X>
-   static char test(int, typename X::element_type*);
-
-   template <typename X>
-   static int test(...);
-
-   static const bool value = (1 == sizeof(test<T>(0, 0)));
-};
-
-template<class Ptr, bool = has_internal_pointer_element<Ptr>::value>
-struct pointer_element_impl
-{
-   typedef typename Ptr::element_type type;
-};
-
-template<class Ptr>
-struct pointer_element_impl<Ptr, false>
-{
-   typedef typename boost::intrusive::detail::first_param<Ptr>::type type;
-};
-
-}  //namespace detail{
-
-template <typename Ptr>
-struct pointer_element
-{
-   typedef typename ::boost::intrusive::detail::pointer_element_impl<Ptr>::type type;
-};
-
-template <typename T>
-struct pointer_element<T*>
-{  typedef T type; };
-
-}  //namespace container {
+}  //namespace intrusive {
 }  //namespace boost {
 
 #endif // defined(BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP)
diff --git a/include/boost/intrusive/detail/to_raw_pointer.hpp b/include/boost/intrusive/detail/to_raw_pointer.hpp
index 8ea8849..1b78750 100644
--- a/include/boost/intrusive/detail/to_raw_pointer.hpp
+++ b/include/boost/intrusive/detail/to_raw_pointer.hpp
@@ -23,20 +23,13 @@
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/detail/workaround.hpp>
-#include <boost/intrusive/detail/pointer_element.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost {
 namespace intrusive {
 namespace detail {
 
-template <class T>
-BOOST_INTRUSIVE_FORCEINLINE T* to_raw_pointer(T* p)
-{  return p; }
-
-template <class Pointer>
-BOOST_INTRUSIVE_FORCEINLINE typename boost::intrusive::pointer_element<Pointer>::type*
-to_raw_pointer(const Pointer &p)
-{  return boost::intrusive::detail::to_raw_pointer(p.operator->());  }
+using ::boost::movelib::to_raw_pointer;
 
 } //namespace detail
 } //namespace intrusive

From db15ff6c089997a1a24276d93d729ac5ef0a6375 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <igaztanaga@gmail.com>
Date: Thu, 6 Apr 2017 23:32:39 +0200
Subject: [PATCH 4/6] Allow non std::size_t size_type.

---
 include/boost/intrusive/hashtable.hpp | 123 +++++++++++++++-----------
 test/unordered_set_test.cpp           |   1 +
 2 files changed, 70 insertions(+), 54 deletions(-)

diff --git a/include/boost/intrusive/hashtable.hpp b/include/boost/intrusive/hashtable.hpp
index 313da82..5f3145c 100644
--- a/include/boost/intrusive/hashtable.hpp
+++ b/include/boost/intrusive/hashtable.hpp
@@ -117,6 +117,24 @@ struct prime_list_holder
 {
    static const std::size_t prime_list[];
    static const std::size_t prime_list_size;
+
+   static std::size_t suggested_upper_bucket_count(std::size_t n)
+   {
+      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
+      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
+      std::size_t const* bound = std::lower_bound(primes, primes_end, n);
+      bound -= (bound == primes_end);
+      return *bound;
+   }
+
+   static std::size_t suggested_lower_bucket_count(std::size_t n)
+   {
+      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
+      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
+      std::size_t const* bound = std::upper_bound(primes, primes_end, n);
+      bound -= (bound != primes);
+      return *bound;
+   }
 };
 
 #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -588,7 +606,6 @@ struct bucket_plus_vtraits
    typedef typename value_traits::node_traits            node_traits;
    typedef unordered_group_adapter<node_traits>          group_traits;
    typedef typename slist_impl::iterator                 siterator;
-   typedef typename slist_impl::size_type                size_type;
    typedef detail::bucket_impl<slist_impl>               bucket_type;
    typedef detail::group_functions<node_traits>          group_functions_t;
    typedef typename slist_impl::node_algorithms          node_algorithms;
@@ -655,7 +672,7 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const
    {  return this->priv_bucket_traits().bucket_begin();  }
 
-   typename slist_impl::size_type priv_bucket_count() const
+   std::size_t priv_bucket_count() const
    {  return this->priv_bucket_traits().bucket_count();  }
 
    BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_invalid_bucket() const
@@ -668,9 +685,9 @@ struct bucket_plus_vtraits
    {  return this->priv_bucket_traits().bucket_begin()->before_begin();  }
 
    template<class NodeDisposer>
-   static size_type priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::true_)   //optimize multikey
+   static std::size_t priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::true_)   //optimize multikey
    {
-      size_type n = 0;
+      std::size_t n = 0;
       siterator const sfirst(++siterator(sbefore_first));
       if(sfirst != slast){
          node_ptr const nf = detail::dcast_bucket_ptr<node>(sfirst.pointed_node());
@@ -708,9 +725,9 @@ struct bucket_plus_vtraits
    }
 
    template<class NodeDisposer>
-   static size_type priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::false_)   //optimize multikey
+   static std::size_t priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::false_)   //optimize multikey
    {
-      size_type n = 0;
+      std::size_t n = 0;
       siterator it(++siterator(sbefore_first));
       while(it != slast){
          node_disposer((it++).pointed_node());
@@ -757,17 +774,17 @@ struct bucket_plus_vtraits
    {  b.erase_after_and_dispose(b.previous(i), node_disposer);   }
 
    template<class NodeDisposer, bool OptimizeMultikey>
-   size_type priv_erase_node_range( siterator const &before_first_it,  size_type const first_bucket
-                        , siterator const &last_it,          size_type const last_bucket
+   std::size_t priv_erase_node_range( siterator const &before_first_it,  std::size_t const first_bucket
+                        , siterator const &last_it,          std::size_t const last_bucket
                         , NodeDisposer node_disposer, detail::bool_<OptimizeMultikey> optimize_multikey_tag)
    {
-      size_type num_erased(0);
+      std::size_t num_erased(0);
       siterator last_step_before_it;
       if(first_bucket != last_bucket){
          bucket_type *b = (&this->priv_bucket_pointer()[0]);
          num_erased += this->priv_erase_from_single_bucket
             (b[first_bucket], before_first_it, b[first_bucket].end(), node_disposer, optimize_multikey_tag);
-         for(size_type i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){
+         for(std::size_t i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){
             num_erased += this->priv_erase_whole_bucket(b[first_bucket+i+1], node_disposer);
          }
          last_step_before_it = b[last_bucket].before_begin();
@@ -797,9 +814,9 @@ struct bucket_plus_vtraits
    }
 
    template<class NodeDisposer>
-   size_type priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer)
+   std::size_t priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer)
    {
-      size_type num_erased = 0;
+      std::size_t num_erased = 0;
       siterator b_begin(b.before_begin());
       siterator nxt(b_begin);
       ++nxt;
@@ -841,7 +858,7 @@ struct bucket_plus_vtraits
       const bucket_type &b = static_cast<const bucket_type&>
          (bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb)));
       //Now just calculate the index b has in the bucket array
-      return static_cast<size_type>(&b - &*f);
+      return static_cast<std::size_t>(&b - &*f);
    }
 
    std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_)   //NO optimize multikey
@@ -881,10 +898,10 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE const_reference priv_value_from_slist_node(slist_node_ptr n) const
    {  return *this->priv_value_traits().to_value_ptr(detail::dcast_bucket_ptr<node>(n)); }
 
-   void priv_clear_buckets(const bucket_ptr buckets_ptr, const size_type bucket_cnt)
+   void priv_clear_buckets(const bucket_ptr buckets_ptr, const std::size_t bucket_cnt)
    {
       bucket_ptr buckets_it = buckets_ptr;
-      for(size_type bucket_i = 0; bucket_i != bucket_cnt; ++buckets_it, ++bucket_i){
+      for(std::size_t bucket_i = 0; bucket_i != bucket_cnt; ++buckets_it, ++bucket_i){
          if(safemode_or_autounlink){
             buckets_it->clear_and_dispose(detail::init_disposer<node_algorithms>());
          }
@@ -909,24 +926,6 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const
    {  return const_iterator(this->priv_invalid_local_it(), 0);  }
 
-   static size_type suggested_upper_bucket_count(size_type n)
-   {
-      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
-      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
-      std::size_t const* bound = std::lower_bound(primes, primes_end, n);
-      bound -= (bound == primes_end);
-      return size_type(*bound);
-   }
-
-   static size_type suggested_lower_bucket_count(size_type n)
-   {
-      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
-      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
-      size_type const* bound = std::upper_bound(primes, primes_end, n);
-      bound -= (bound != primes);
-      return size_type(*bound);
-   }
-
    //Public functions:
    struct data_type : public ValueTraits
    {
@@ -1072,7 +1071,6 @@ struct bucket_hash_equal_t
    typedef typename bucket_hash_type::hasher    hasher;
    typedef BucketTraits                         bucket_traits;
    typedef typename bucket_plus_vtraits_t::slist_impl       slist_impl;
-   typedef typename slist_impl::size_type                   size_type;
    typedef typename slist_impl::iterator                    siterator;
    typedef detail::bucket_impl<slist_impl>                  bucket_type;
    typedef typename detail::unordered_bucket_ptr_impl<value_traits>::type bucket_ptr;
@@ -1089,7 +1087,7 @@ struct bucket_hash_equal_t
    BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache(const bucket_ptr &)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_cache_bucket_num()
+   BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num()
    {  return 0u;  }
 
    BOOST_INTRUSIVE_FORCEINLINE void priv_initialize_cache()
@@ -1100,8 +1098,8 @@ struct bucket_hash_equal_t
 
    siterator priv_begin() const
    {
-      size_type n = 0;
-      size_type bucket_cnt = this->bucket_hash_type::priv_bucket_count();
+      std::size_t n = 0;
+      std::size_t bucket_cnt = this->bucket_hash_type::priv_bucket_count();
       for (n = 0; n < bucket_cnt; ++n){
          bucket_type &b = this->bucket_hash_type::priv_bucket_pointer()[n];
          if(!b.empty()){
@@ -1111,10 +1109,10 @@ struct bucket_hash_equal_t
       return this->bucket_hash_type::priv_invalid_local_it();
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void priv_insertion_update_cache(size_type)
+   BOOST_INTRUSIVE_FORCEINLINE void priv_insertion_update_cache(std::size_t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache_range(size_type, size_type)
+   BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache_range(std::size_t, std::size_t)
    {}
 
    BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache()
@@ -1145,7 +1143,6 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    typedef bucket_hash_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, BucketTraits>   bucket_hash_type;
    typedef typename bucket_hash_type::hasher                         hasher;
    typedef BucketTraits                                              bucket_traits;
-   typedef typename bucket_plus_vtraits_t::slist_impl::size_type     size_type;
    typedef typename bucket_plus_vtraits_t::slist_impl::iterator      siterator;
 
    template<class BucketTraitsType>
@@ -1187,7 +1184,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
       }
    }
 
-   void priv_insertion_update_cache(size_type insertion_bucket)
+   void priv_insertion_update_cache(std::size_t insertion_bucket)
    {
       bucket_ptr p = this->bucket_hash_type::priv_bucket_pointer() + insertion_bucket;
       if(p < this->cached_begin_){
@@ -1201,7 +1198,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    BOOST_INTRUSIVE_FORCEINLINE key_equal &priv_equal()
    {  return this->equal_holder_t::get();  }
 
-   void priv_erasure_update_cache_range(size_type first_bucket_num, size_type last_bucket_num)
+   void priv_erasure_update_cache_range(std::size_t first_bucket_num, std::size_t last_bucket_num)
    {
       //If the last bucket is the end, the cache must be updated
       //to the last position if all
@@ -1215,8 +1212,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    void priv_erasure_update_cache()
    {
       if(this->cached_begin_ != this->bucket_hash_type::priv_invalid_bucket()){
-         size_type current_n = this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer();
-         for( const size_type num_buckets = this->bucket_hash_type::priv_bucket_count()
+         std::size_t current_n = this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer();
+         for( const std::size_t num_buckets = this->bucket_hash_type::priv_bucket_count()
             ; current_n < num_buckets
             ; ++current_n, ++this->priv_get_cache()){
             if(!this->priv_get_cache()->empty()){
@@ -1307,7 +1304,7 @@ struct hashdata_internal
    typedef typename internal_type::key_equal                key_equal;
    typedef typename internal_type::hasher                   hasher;
    typedef bucket_plus_vtraits<ValueTraits,BucketTraits>    bucket_plus_vtraits_t;
-   typedef typename bucket_plus_vtraits_t::size_type        size_type;
+   typedef SizeType                                         size_type;
    typedef typename internal_type::size_traits              split_traits;
    typedef typename bucket_plus_vtraits_t::bucket_ptr       bucket_ptr;
    typedef typename bucket_plus_vtraits_t::const_value_traits_ptr   const_value_traits_ptr;
@@ -1459,7 +1456,11 @@ struct hashdata_internal
    }
 
    BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const
-   {  return this->priv_bucket_count();   }
+   {
+      const std::size_t bc = this->priv_bucket_count();
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(sizeof(size_type) >= sizeof(std::size_t) || bc <= size_type(-1));
+      return static_cast<size_type>(bc);
+   }
 
    BOOST_INTRUSIVE_FORCEINLINE size_type bucket_size(size_type n) const
    {  return this->priv_bucket_pointer()[n].size();   }
@@ -1473,6 +1474,20 @@ struct hashdata_internal
    BOOST_INTRUSIVE_FORCEINLINE const_local_iterator begin(size_type n) const
    {  return this->cbegin(n);  }
 
+   static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_upper_bucket_count(size_type n)
+   {
+      std::size_t c = prime_list_holder<0>::suggested_upper_bucket_count
+         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
+      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+   }
+
+   static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n)
+   {
+      std::size_t c = prime_list_holder<0>::suggested_lower_bucket_count
+         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
+      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+   }
+
    const_local_iterator cbegin(size_type n) const
    {
       return const_local_iterator
@@ -1737,7 +1752,7 @@ class hashtable_impl
    {
       this->priv_initialize_buckets_and_cache();
       this->priv_size_traits().set_size(size_type(0));
-      size_type bucket_sz = this->priv_bucket_count();
+      size_type bucket_sz = this->bucket_count();
       BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_sz != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -1770,7 +1785,7 @@ class hashtable_impl
    {
       this->priv_initialize_buckets_and_cache();
       this->priv_size_traits().set_size(size_type(0));
-      size_type bucket_sz = this->priv_bucket_count();
+      size_type bucket_sz = this->bucket_count();
       BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_sz != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -1894,7 +1909,7 @@ class hashtable_impl
          return this->begin() == this->end();
       }
       else{
-         size_type bucket_cnt = this->priv_bucket_count();
+         size_type bucket_cnt = this->bucket_count();
          const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             if(!b->empty()){
@@ -1917,7 +1932,7 @@ class hashtable_impl
          return this->priv_size_traits().get_size();
       else{
          size_type len = 0;
-         size_type bucket_cnt = this->priv_bucket_count();
+         size_type bucket_cnt = this->bucket_count();
          const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             len += b->size();
@@ -2898,7 +2913,7 @@ class hashtable_impl
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
       const size_type split_idx  = this->priv_split_traits().get_size();
-      const size_type bucket_cnt = this->priv_bucket_count();
+      const size_type bucket_cnt = this->bucket_count();
       const bucket_ptr buck_ptr  = this->priv_bucket_pointer();
       bool ret = false;
 
@@ -2961,7 +2976,7 @@ class hashtable_impl
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
       size_type const new_bucket_traits_size = new_bucket_traits.bucket_count();
-      size_type const cur_bucket_traits      = this->priv_bucket_count();
+      size_type const cur_bucket_traits      = this->bucket_count();
       const size_type split_idx = this->split_count();
 
       //Test new bucket size is consistent with internal bucket size and split count
@@ -3071,7 +3086,7 @@ class hashtable_impl
       const bucket_ptr new_buckets      = new_bucket_traits.bucket_begin();
             size_type  new_bucket_count = new_bucket_traits.bucket_count();
       const bucket_ptr old_buckets      = this->priv_bucket_pointer();
-            size_type  old_bucket_count = this->priv_bucket_count();
+            size_type  old_bucket_count = this->bucket_count();
 
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -3400,7 +3415,7 @@ class hashtable_impl
          to_return.second == bp[n_bucket].end()){
          to_return.second = this->priv_invalid_local_it();
          ++n_bucket;
-         for( const size_type max_bucket = this->priv_bucket_count()
+         for( const size_type max_bucket = this->bucket_count()
             ; n_bucket != max_bucket
             ; ++n_bucket){
             bucket_type &b = bp[n_bucket];
diff --git a/test/unordered_set_test.cpp b/test/unordered_set_test.cpp
index 59a7b70..60e8d36 100644
--- a/test/unordered_set_test.cpp
+++ b/test/unordered_set_test.cpp
@@ -45,6 +45,7 @@ struct rebinder
          , incremental<Incremental>
          , typename common_t::holder_opt
          , typename common_t::key_of_value_opt
+         , size_type<unsigned short>
          , Option1
          , Option2
          > type;

From 018a39c433d09bc9f01f1c90725e0013fb1bbeb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <igaztanaga@gmail.com>
Date: Fri, 7 Apr 2017 16:05:44 +0200
Subject: [PATCH 5/6] Use directly
 boost::movelib::pointer_element/to_raw_pointer

---
 include/boost/intrusive/bstree.hpp            |  3 +-
 .../detail/default_header_holder.hpp          |  4 +-
 .../boost/intrusive/detail/hashtable_node.hpp |  2 +-
 .../boost/intrusive/detail/hook_traits.hpp    | 10 ++---
 .../boost/intrusive/detail/node_to_value.hpp  |  2 +-
 .../intrusive/detail/pointer_element.hpp      | 42 -------------------
 .../boost/intrusive/detail/to_raw_pointer.hpp | 40 ------------------
 .../intrusive/detail/tree_value_compare.hpp   | 12 ++++--
 include/boost/intrusive/hashtable.hpp         |  4 +-
 .../boost/intrusive/member_value_traits.hpp   |  6 +--
 include/boost/intrusive/pointer_traits.hpp    |  4 +-
 .../vc7ide/_intrusivelib/_intrusivelib.vcproj |  6 ---
 test/common_functors.hpp                      |  3 +-
 test/nonhook_node.hpp                         | 11 ++---
 14 files changed, 34 insertions(+), 115 deletions(-)
 delete mode 100644 include/boost/intrusive/detail/pointer_element.hpp
 delete mode 100644 include/boost/intrusive/detail/to_raw_pointer.hpp

diff --git a/include/boost/intrusive/bstree.hpp b/include/boost/intrusive/bstree.hpp
index 1eeab55..ac67e86 100644
--- a/include/boost/intrusive/bstree.hpp
+++ b/include/boost/intrusive/bstree.hpp
@@ -255,7 +255,8 @@ struct get_key_of_value<void, T>
 template<class ValuePtr, class VoidOrKeyOfValue, class VoidOrKeyComp>
 struct bst_key_types
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef typename get_key_of_value
       < VoidOrKeyOfValue, value_type>::type           key_of_value;
    typedef typename key_of_value::type                key_type;
diff --git a/include/boost/intrusive/detail/default_header_holder.hpp b/include/boost/intrusive/detail/default_header_holder.hpp
index 288f8a0..ba561b5 100644
--- a/include/boost/intrusive/detail/default_header_holder.hpp
+++ b/include/boost/intrusive/detail/default_header_holder.hpp
@@ -23,7 +23,7 @@
 
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -48,7 +48,7 @@ struct default_header_holder : public NodeTraits::node
 
    // (unsafe) downcast used to implement container-from-iterator
    BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
-   { return static_cast< default_header_holder* >(boost::intrusive::detail::to_raw_pointer(p)); }
+   { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 
 // type function producing the header node holder
diff --git a/include/boost/intrusive/detail/hashtable_node.hpp b/include/boost/intrusive/detail/hashtable_node.hpp
index 8f8718e..d3b11d1 100644
--- a/include/boost/intrusive/detail/hashtable_node.hpp
+++ b/include/boost/intrusive/detail/hashtable_node.hpp
@@ -246,7 +246,7 @@ class hashtable_iterator
    void increment()
    {
       const bucket_traits &rbuck_traits = this->priv_bucket_traits();
-      bucket_type* const buckets = boost::intrusive::detail::to_raw_pointer(rbuck_traits.bucket_begin());
+      bucket_type* const buckets = boost::movelib::to_raw_pointer(rbuck_traits.bucket_begin());
       const size_type buckets_len = rbuck_traits.bucket_count();
 
       ++slist_it_;
diff --git a/include/boost/intrusive/detail/hook_traits.hpp b/include/boost/intrusive/detail/hook_traits.hpp
index 2a16061..7a6f206 100644
--- a/include/boost/intrusive/detail/hook_traits.hpp
+++ b/include/boost/intrusive/detail/hook_traits.hpp
@@ -26,7 +26,7 @@
 #include <boost/intrusive/detail/parent_from_member.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 
 namespace boost {
@@ -128,14 +128,14 @@ struct mhtraits
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
    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<T, Hook>
-            (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 };
 
@@ -161,10 +161,10 @@ struct fhtraits
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
    static node_ptr to_node_ptr(reference value)
-   {  return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(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)
-   {  return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(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)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
diff --git a/include/boost/intrusive/detail/node_to_value.hpp b/include/boost/intrusive/detail/node_to_value.hpp
index 5af3347..218e78e 100644
--- a/include/boost/intrusive/detail/node_to_value.hpp
+++ b/include/boost/intrusive/detail/node_to_value.hpp
@@ -59,7 +59,7 @@ struct constptr
    {}
 
    const void *get_ptr() const
-   {  return boost::intrusive::detail::to_raw_pointer(const_void_ptr_);  }
+   {  return boost::movelib::to_raw_pointer(const_void_ptr_);  }
 
    ConstVoidPtr const_void_ptr_;
 };
diff --git a/include/boost/intrusive/detail/pointer_element.hpp b/include/boost/intrusive/detail/pointer_element.hpp
deleted file mode 100644
index 235ecf4..0000000
--- a/include/boost/intrusive/detail/pointer_element.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/intrusive for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
-#define BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
-#include <boost/intrusive/detail/workaround.hpp>
-#endif   //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
-
-#include <boost/move/detail/pointer_element.hpp>
-
-namespace boost {
-namespace intrusive {
-
-using ::boost::movelib::pointer_element;
-
-namespace detail {
-
-using ::boost::movelib::detail::first_param;
-
-}
-
-}  //namespace intrusive {
-}  //namespace boost {
-
-#endif // defined(BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP)
diff --git a/include/boost/intrusive/detail/to_raw_pointer.hpp b/include/boost/intrusive/detail/to_raw_pointer.hpp
deleted file mode 100644
index 1b78750..0000000
--- a/include/boost/intrusive/detail/to_raw_pointer.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga  2014-2014
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/intrusive for documentation.
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
-#define BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/intrusive/detail/workaround.hpp>
-#include <boost/move/detail/to_raw_pointer.hpp>
-
-namespace boost {
-namespace intrusive {
-namespace detail {
-
-using ::boost::movelib::to_raw_pointer;
-
-} //namespace detail
-} //namespace intrusive
-} //namespace boost
-
-#include <boost/intrusive/detail/config_end.hpp>
-
-#endif //BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP
diff --git a/include/boost/intrusive/detail/tree_value_compare.hpp b/include/boost/intrusive/detail/tree_value_compare.hpp
index c8f596f..f6dd01d 100644
--- a/include/boost/intrusive/detail/tree_value_compare.hpp
+++ b/include/boost/intrusive/detail/tree_value_compare.hpp
@@ -37,7 +37,8 @@ struct disable_if_smartref_to
       || detail::is_same
             <From, typename pointer_traits
                      < typename pointer_rebind
-                           <ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
+                           < ValuePtr
+                           , const typename boost::movelib::pointer_element<ValuePtr>::type>::type>
                   ::reference>::value
       >
 {};
@@ -45,11 +46,13 @@ struct disable_if_smartref_to
 //This function object takes a KeyCompare function object
 //and compares values that contains keys using KeyOfValue
 template< class ValuePtr, class KeyCompare, class KeyOfValue
-        , bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
+        , bool = boost::intrusive::detail::is_same
+   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
 struct tree_value_compare
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
@@ -114,7 +117,8 @@ template<class ValuePtr, class KeyCompare, class KeyOfValue>
 struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
diff --git a/include/boost/intrusive/hashtable.hpp b/include/boost/intrusive/hashtable.hpp
index 5f3145c..bae9d52 100644
--- a/include/boost/intrusive/hashtable.hpp
+++ b/include/boost/intrusive/hashtable.hpp
@@ -1910,7 +1910,7 @@ class hashtable_impl
       }
       else{
          size_type bucket_cnt = this->bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             if(!b->empty()){
                return false;
@@ -1933,7 +1933,7 @@ class hashtable_impl
       else{
          size_type len = 0;
          size_type bucket_cnt = this->bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             len += b->size();
          }
diff --git a/include/boost/intrusive/member_value_traits.hpp b/include/boost/intrusive/member_value_traits.hpp
index 4efe79e..0ab7ffb 100644
--- a/include/boost/intrusive/member_value_traits.hpp
+++ b/include/boost/intrusive/member_value_traits.hpp
@@ -18,7 +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/move/detail/to_raw_pointer.hpp> 
 #include <boost/intrusive/pointer_traits.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -66,13 +66,13 @@ struct member_value_traits
    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));
+         (boost::movelib::to_raw_pointer(n), PtrToMember));
    }
 
    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));
+         (boost::movelib::to_raw_pointer(n), PtrToMember));
 
    }
 };
diff --git a/include/boost/intrusive/pointer_traits.hpp b/include/boost/intrusive/pointer_traits.hpp
index 5baf5e8..4216c7e 100644
--- a/include/boost/intrusive/pointer_traits.hpp
+++ b/include/boost/intrusive/pointer_traits.hpp
@@ -20,7 +20,7 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
-#include <boost/intrusive/detail/pointer_element.hpp>
+#include <boost/move/detail/pointer_element.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <cstddef>
 
@@ -97,7 +97,7 @@ struct pointer_traits
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT
          ( boost::intrusive::detail::, Ptr, element_type
-         , boost::intrusive::detail::first_param<Ptr>)                        element_type;
+         , boost::movelib::detail::first_param<Ptr>)                          element_type;
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
          (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
diff --git a/proj/vc7ide/_intrusivelib/_intrusivelib.vcproj b/proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
index 03bbd15..de144c3 100644
--- a/proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
+++ b/proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
@@ -337,9 +337,6 @@
 				<File
 					RelativePath="..\..\..\..\..\boost\intrusive\detail\parent_from_member.hpp">
 				</File>
-				<File
-					RelativePath="..\..\..\..\..\boost\intrusive\detail\pointer_element.hpp">
-				</File>
 				<File
 					RelativePath="..\..\..\..\..\boost\intrusive\detail\rbtree_node.hpp">
 				</File>
@@ -361,9 +358,6 @@
 				<File
 					RelativePath="..\..\..\..\..\boost\intrusive\detail\std_fwd.hpp">
 				</File>
-				<File
-					RelativePath="..\..\..\..\..\boost\intrusive\detail\to_raw_pointer.hpp">
-				</File>
 				<File
 					RelativePath="..\..\..\..\..\boost\intrusive\detail\transform_iterator.hpp">
 				</File>
diff --git a/test/common_functors.hpp b/test/common_functors.hpp
index 4e6ac8d..b84a84a 100644
--- a/test/common_functors.hpp
+++ b/test/common_functors.hpp
@@ -16,6 +16,7 @@
 #include<boost/intrusive/detail/iterator.hpp>
 #include<boost/intrusive/detail/mpl.hpp>
 #include<boost/static_assert.hpp>
+#include<boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost      {
 namespace intrusive  {
@@ -30,7 +31,7 @@ class delete_disposer
    {
       typedef typename boost::intrusive::iterator_traits<Pointer>::value_type value_type;
       BOOST_STATIC_ASSERT(( detail::is_same<T, value_type>::value ));
-      delete boost::intrusive::detail::to_raw_pointer(p);
+      delete boost::movelib::to_raw_pointer(p);
    }
 };
 
diff --git a/test/nonhook_node.hpp b/test/nonhook_node.hpp
index 8e3d6d3..e2c666e 100644
--- a/test/nonhook_node.hpp
+++ b/test/nonhook_node.hpp
@@ -15,11 +15,12 @@
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/parent_from_member.hpp>
 
+#include <boost/move/detail/to_raw_pointer.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 namespace boost{
 namespace intrusive{
@@ -103,14 +104,14 @@ struct nonhook_node_member_value_traits
    {
       return pointer_traits<pointer>::pointer_to
       (*detail::parent_from_member<T, NonHook_Member>
-      (static_cast<NonHook_Member*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+      (static_cast<NonHook_Member*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
    static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer_traits<const_pointer>::pointer_to
       (*detail::parent_from_member<T, NonHook_Member>
-      (static_cast<const NonHook_Member*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+      (static_cast<const NonHook_Member*>(boost::movelib::to_raw_pointer(n)), P));
    }
 };
 

From 3bf6ff9c30b32a1198b85b4a79ee5094a4c47140 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= <igaztanaga@gmail.com>
Date: Sun, 9 Apr 2017 22:09:51 +0200
Subject: [PATCH 6/6] Fix Trac ticket #12762: "Incorrect documentation for
 boost::intrusive::size_type<typename>"

---
 doc/intrusive.qbk | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/doc/intrusive.qbk b/doc/intrusive.qbk
index 88dfc50..24b095b 100644
--- a/doc/intrusive.qbk
+++ b/doc/intrusive.qbk
@@ -331,7 +331,7 @@ and optionally, the user can specify options. We have 3 option types:
    containers can have a `size_type` that might be different from `std::size_t`
    (for example, STL-like containers use the `size_type` defined by their allocator).
    [*Boost.Intrusive] can be used to implement such containers specifying the
-   the type of the size. By default the type is `std::size_t`.
+   type of the size. By default the type is `std::size_t`.
 
 Example of a constant-time size intrusive list that will store Foo objects, using
 the base hook with the default tag:
@@ -863,7 +863,7 @@ the section [link intrusive.usage How to use Boost.Intrusive]:
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`.
 
 [classref boost::intrusive::slist slist] can receive additional options:
@@ -965,7 +965,7 @@ the section [link intrusive.usage How to use Boost.Intrusive]:
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 [endsect]
@@ -1089,7 +1089,7 @@ These containers receive the same options explained in the section
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive an additional option:
@@ -1279,7 +1279,7 @@ receive the same options explained in the section
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive additional options:
@@ -1511,7 +1511,7 @@ These containers receive the same options explained in the section
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive an additional option:
@@ -1613,7 +1613,7 @@ These containers receive the same options explained in the section
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive an additional option:
@@ -1724,7 +1724,7 @@ These containers receive the same options explained in the section
    to configure the container. (To learn about value traits go to the section
    [link intrusive.value_traits Containers with custom ValueTraits].)
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive additional options:
@@ -1827,7 +1827,7 @@ These containers receive the same options explained in the section
 *  [*`constant_time_size<bool Enabled>`]: To activate the constant-time `size()` operation.
    Default: `constant_time_size<true>`
 
-*  [*`size_type<bool Enabled>`]: To specify the type that will be used to store the size
+*  [*`size_type<typename SizeType>`]: To specify the type that will be used to store the size
    of the container. Default: `size_type<std::size_t>`
 
 And they also can receive additional options:
@@ -3865,6 +3865,13 @@ to be inserted in intrusive containers are allocated using `std::vector` or `std
 
 [section:release_notes Release Notes]
 
+[section:release_notes_boost_1_65_00 Boost 1.65 Release]
+
+*  Fixed bugs:
+   *  [@https://svn.boost.org/trac/boost/ticket/12894 Boost Trac #12894: ['Allow non std::size_t size_type]]
+
+[endsect]
+
 [section:release_notes_boost_1_64_00 Boost 1.64 Release]
 
 *  Fixed bugs: