passenger 5.3.3 → 5.3.4

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

@@ -115,8 +115,89 @@ bool priv_algo_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, F
 template<int Dummy = 0>
 struct prime_list_holder
 {
+   private:
+
+   template <class SizeType> // sizeof(SizeType) < sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::true_)
+   {
+      return n < std::size_t(SizeType(-1)) ? static_cast<SizeType>(n) : SizeType(-1);
+   }
+
+   template <class SizeType> // sizeof(SizeType) == sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::false_)
+   {
+      return static_cast<SizeType>(n);
+   }
+
+   template <class SizeType>  //sizeof(SizeType) > sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::true_)
+   {
+      std::size_t const c = n > std::size_t(-1)
+                            ? std::size_t(-1)
+                            : suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+      return static_cast<SizeType>(c);
+   }
+
+   template <class SizeType>  //sizeof(SizeType) > sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::true_)
+   {
+      std::size_t const c = n > std::size_t(-1)
+                            ? std::size_t(-1)
+                            : suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+      return static_cast<SizeType>(c);
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::false_)
+   {
+      std::size_t const c = suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+      return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::false_)
+   {
+      std::size_t const c = suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+      return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+   }
+
    static const std::size_t prime_list[];
    static const std::size_t prime_list_size;
+
+   static std::size_t suggested_lower_bucket_count_impl(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);
+      //Tables have upper SIZE_MAX, so we must always found an entry
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(bound != primes_end);
+      bound -= std::size_t(bound != primes);
+      return *bound;
+   }
+
+   static std::size_t suggested_upper_bucket_count_impl(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 -= std::size_t(bound == primes_end);
+      return *bound;
+   }
+
+   public:
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count(SizeType n)
+   {
+      return (suggested_upper_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count(SizeType n)
+   {
+      return (suggested_lower_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+   }
 };
 
 #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -166,9 +247,9 @@ const std::size_t prime_list_holder<Dummy>::prime_list[] = {
    BOOST_INTRUSIVE_PRIME_C(432345564227567621),    BOOST_INTRUSIVE_PRIME_C(864691128455135207),
    BOOST_INTRUSIVE_PRIME_C(1729382256910270481),   BOOST_INTRUSIVE_PRIME_C(3458764513820540933),
    BOOST_INTRUSIVE_PRIME_C(6917529027641081903),   BOOST_INTRUSIVE_PRIME_C(13835058055282163729),
-   BOOST_INTRUSIVE_PRIME_C(18446744073709551557)
+   BOOST_INTRUSIVE_PRIME_C(18446744073709551557),  BOOST_INTRUSIVE_PRIME_C(18446744073709551615)   //Upper limit, just in case
 #else
-   BOOST_INTRUSIVE_PRIME_C(4294967291)
+   BOOST_INTRUSIVE_PRIME_C(4294967291),            BOOST_INTRUSIVE_PRIME_C(4294967295)             //Upper limit, just in case
 #endif
    };
 
@@ -588,7 +669,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 +735,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 +748,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 +788,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 +837,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 +877,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 +921,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 +961,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 +989,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 +1134,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 +1150,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 +1161,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 +1172,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 +1206,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 +1247,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 +1261,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 +1275,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 +1367,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 +1519,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 +1537,16 @@ 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)
+   {
+      return prime_list_holder<0>::suggested_upper_bucket_count(n);
+   }
+
+   static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n)
+   {
+      return prime_list_holder<0>::suggested_lower_bucket_count(n);
+   }
+
    const_local_iterator cbegin(size_type n) const
    {
       return const_local_iterator
@@ -1482,6 +1556,7 @@ struct hashdata_internal
 
    using internal_type::end;
    using internal_type::cend;
+
    local_iterator end(size_type n)
    {  return local_iterator(this->priv_bucket_pointer()[n].end(), this->priv_value_traits_ptr());  }
 
@@ -1737,7 +1812,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 +1845,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
@@ -1783,8 +1858,15 @@ class hashtable_impl
          this->insert_equal(b, e);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Constructs a container moving resources from another container.
+   //!   Internal value traits, bucket traits, hasher and comparison are move constructed and
+   //!   nodes belonging to x are linked to *this.
+   //!
+   //! <b>Complexity</b>: Constant.
    //!
+   //! <b>Throws</b>: If value_traits::node_traits::node's
+   //!   move constructor throws (this does not happen with predefined Boost.Intrusive hooks)
+   //!   or the move constructor of value traits, bucket traits, hasher or comparison throws.
    hashtable_impl(BOOST_RV_REF(hashtable_impl) x)
       : internal_type( ::boost::move(x.priv_value_traits())
                      , ::boost::move(x.priv_bucket_traits())
@@ -1800,7 +1882,7 @@ class hashtable_impl
       x.priv_split_traits().set_size(size_type(0));
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Equivalent to swap.
    //!
    hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x)
    {  this->swap(x); return *this;  }
@@ -1894,8 +1976,8 @@ class hashtable_impl
          return this->begin() == this->end();
       }
       else{
-         size_type bucket_cnt = this->priv_bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         size_type bucket_cnt = this->bucket_count();
+         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;
@@ -1917,8 +1999,8 @@ class hashtable_impl
          return this->priv_size_traits().get_size();
       else{
          size_type len = 0;
-         size_type bucket_cnt = this->priv_bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         size_type bucket_cnt = this->bucket_count();
+         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();
          }
@@ -2898,7 +2980,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 +3043,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 +3153,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
@@ -3348,7 +3430,7 @@ class hashtable_impl
       , size_type &found_bucket
       , size_type &cnt) const
    {
-      cnt = 0;
+      size_type internal_cnt = 0;
       //Let's see if the element is present
       
       siterator prev;
@@ -3364,20 +3446,21 @@ class hashtable_impl
          //the same bucket
          bucket_type &b = this->priv_bucket_pointer()[n_bucket];
          siterator it = to_return.first;
-         ++cnt;   //At least one is found
+         ++internal_cnt;   //At least one is found
          if(optimize_multikey){
             to_return.second = ++(priv_last_in_group)(it);
-            cnt += boost::intrusive::iterator_distance(++it, to_return.second);
+            internal_cnt += boost::intrusive::iterator_distance(++it, to_return.second);
          }
          else{
             siterator const bend = b.end();
             while(++it != bend &&
                   this->priv_is_value_equal_to_key(this->priv_value_from_slist_node(it.pointed_node()), h, key, equal_func)){
-               ++cnt;
+               ++internal_cnt;
             }
             to_return.second = it;
          }
       }
+      cnt = internal_cnt;
       return to_return;
    }
 
@@ -3400,7 +3483,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];