Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r80191 - trunk/boost/intrusive
From: igaztanaga_at_[hidden]
Date: 2012-08-25 04:23:04


Author: igaztanaga
Date: 2012-08-25 04:23:03 EDT (Sat, 25 Aug 2012)
New Revision: 80191
URL: http://svn.boost.org/trac/boost/changeset/80191

Log:
Added "this->" to improve readability
Text files modified:
   trunk/boost/intrusive/hashtable.hpp | 498 ++++++++++++++++-----------------------
   1 files changed, 209 insertions(+), 289 deletions(-)

Modified: trunk/boost/intrusive/hashtable.hpp
==============================================================================
--- trunk/boost/intrusive/hashtable.hpp (original)
+++ trunk/boost/intrusive/hashtable.hpp 2012-08-25 04:23:03 EDT (Sat, 25 Aug 2012)
@@ -135,7 +135,7 @@
 struct real_from_supposed_value_traits
 {
    typedef typename detail::eval_if_c
- < detail::external_value_traits_is_true
+ < detail::external_value_traits_bool_is_true
          <SupposedValueTraits>::value
       , detail::eval_value_traits
          <SupposedValueTraits>
@@ -384,7 +384,7 @@
       slist_node_ptr possible_end = node_traits::get_next(last_node_group);
 
       while(!(bucket_beg <= possible_end && possible_end <= bucket_end)){
- first_node_of_group = dcast_bucket_ptr(possible_end);
+ first_node_of_group = group_functions::dcast_bucket_ptr(possible_end);
          last_node_group = group_traits::get_next(first_node_of_group);
          possible_end = node_traits::get_next(last_node_group);
       }
@@ -395,7 +395,7 @@
    {
       //Just iterate using group links and obtain the node
       //before "first_in_group)"
- node_ptr prev_node = dcast_bucket_ptr(bucket_node);
+ node_ptr prev_node = group_functions::dcast_bucket_ptr(bucket_node);
       node_ptr nxt(node_traits::get_next(prev_node));
       while(nxt != first_in_group){
          prev_node = group_traits::get_next(nxt);
@@ -480,7 +480,7 @@
       , const slist_node_ptr &first_end_ptr, const slist_node_ptr &last_end_ptr)
    {
       slist_node_ptr prev;
- node_ptr elem(dcast_bucket_ptr(i));
+ node_ptr elem(group_functions::dcast_bucket_ptr(i));
 
       //It's the last in group if the next_node is a bucket
       slist_node_ptr nxt(node_traits::get_next(elem));
@@ -687,7 +687,7 @@
 
    /// @cond
    static const bool external_value_traits =
- detail::external_value_traits_is_true<value_traits>::value;
+ detail::external_value_traits_bool_is_true<value_traits>::value;
    typedef typename detail::eval_if_c
       < external_value_traits
       , detail::eval_value_traits<value_traits>
@@ -695,7 +695,7 @@
>::type real_value_traits;
    typedef typename Config::bucket_traits bucket_traits;
    static const bool external_bucket_traits =
- detail::external_bucket_traits_is_true<bucket_traits>::value;
+ detail::external_bucket_traits_bool_is_true<bucket_traits>::value;
    typedef typename detail::eval_if_c
       < external_bucket_traits
       , detail::eval_bucket_traits<bucket_traits>
@@ -894,14 +894,14 @@
                   , const value_traits &v_traits = value_traits())
       : data_(b_traits, hash_func, equal_func, v_traits)
    {
- priv_initialize_buckets();
+ this->priv_initialize_buckets();
       this->priv_size_traits().set_size(size_type(0));
- size_type bucket_size = this->priv_buckets_len();
+ size_type bucket_size = this->priv_bucket_count();
       BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_size != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
          (!power_2_buckets || (0 == (bucket_size & (bucket_size-1))));
- priv_split_traits().set_size(bucket_size>>1);
+ this->priv_split_traits().set_size(bucket_size>>1);
    }
 
    //! <b>Effects</b>: to-do
@@ -913,7 +913,7 @@
              , ::boost::move(x.priv_value_traits())
              )
    {
- priv_swap_cache(cache_begin_t(), x);
+ this->priv_swap_cache(cache_begin_t(), x);
       x.priv_initialize_cache();
       if(constant_time_size){
          this->priv_size_traits().set_size(size_type(0));
@@ -976,7 +976,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    iterator end()
- { return iterator(priv_invalid_local_it(), 0); }
+ { return iterator(this->priv_invalid_local_it(), 0); }
 
    //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set.
    //!
@@ -992,7 +992,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    const_iterator cend() const
- { return const_iterator(priv_invalid_local_it(), 0); }
+ { return const_iterator(this->priv_invalid_local_it(), 0); }
 
    //! <b>Effects</b>: Returns the hasher object used by the unordered_set.
    //!
@@ -1026,9 +1026,9 @@
          return this->begin() == this->end();
       }
       else{
- size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets());
- for (size_type n = 0; n < buckets_len; ++n, ++b){
+ size_type bucket_count = this->priv_bucket_count();
+ const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+ for (size_type n = 0; n < bucket_count; ++n, ++b){
             if(!b->empty()){
                return false;
             }
@@ -1049,9 +1049,9 @@
          return this->priv_size_traits().get_size();
       else{
          size_type len = 0;
- size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets());
- for (size_type n = 0; n < buckets_len; ++n, ++b){
+ size_type bucket_count = this->priv_bucket_count();
+ const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+ for (size_type n = 0; n < bucket_count; ++n, ++b){
             len += b->size();
          }
          return len;
@@ -1077,7 +1077,7 @@
       //These can't throw
       swap(this->priv_bucket_traits(), other.priv_bucket_traits());
       swap(this->priv_value_traits(), other.priv_value_traits());
- priv_swap_cache(cache_begin_t(), other);
+ this->priv_swap_cache(cache_begin_t(), other);
       if(constant_time_size){
          size_type backup = this->priv_size_traits().get_size();
          this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -1125,8 +1125,8 @@
          //If src bucket count is bigger or equal, structural copy is possible
          if(!incremental && (src_bucket_count >= dst_bucket_count)){
             //First clone the first ones
- const bucket_ptr src_buckets = src.priv_buckets();
- const bucket_ptr dst_buckets = this->priv_buckets();
+ const bucket_ptr src_buckets = src.priv_bucket_pointer();
+ const bucket_ptr dst_buckets = this->priv_bucket_pointer();
             size_type constructed;
             typedef node_cast_adaptor<detail::node_disposer<Disposer, hashtable_impl> > NodeDisposer;
             typedef node_cast_adaptor<detail::node_cloner<Cloner, hashtable_impl> > NodeCloner;
@@ -1147,7 +1147,7 @@
                   ; constructed < src_bucket_count
                   ; ++constructed){
                   bucket_type &dst_b =
- dst_buckets[priv_hash_to_bucket(constructed, dst_bucket_count, dst_bucket_count)];
+ dst_buckets[this->priv_hash_to_bucket(constructed, dst_bucket_count, dst_bucket_count)];
                   bucket_type &src_b = src_buckets[constructed];
                   for( siterator b(src_b.begin()), e(src_b.end())
                      ; b != e
@@ -1161,8 +1161,8 @@
             rollback.release();
             this->priv_size_traits().set_size(src.priv_size_traits().get_size());
             this->priv_split_traits().set_size(dst_bucket_count);
- priv_insertion_update_cache(0u);
- priv_erasure_update_cache();
+ this->priv_insertion_update_cache(0u);
+ this->priv_erasure_update_cache();
          }
          else if(store_hash){
             //Unlike previous cloning algorithm, this can throw
@@ -1209,7 +1209,7 @@
       siterator prev;
       siterator it = this->priv_find
          (value, this->priv_hasher(), this->priv_equal(), bucket_num, hash_value, prev);
- return priv_insert_equal_find(value, bucket_num, hash_value, it);
+ return this->priv_insert_equal_find(value, bucket_num, hash_value, it);
    }
 
    //! <b>Requires</b>: Dereferencing iterator must yield an lvalue
@@ -1323,7 +1323,7 @@
       siterator prev;
       siterator prev_pos =
          this->priv_find(key, hash_func, equal_func, bucket_num, commit_data.hash, prev);
- bool success = prev_pos == priv_invalid_local_it();
+ bool success = prev_pos == this->priv_invalid_local_it();
       if(success){
          prev_pos = prev;
       }
@@ -1351,14 +1351,14 @@
    //! After a successful rehashing insert_commit_data remains valid.
    iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
    {
- size_type bucket_num = priv_hash_to_bucket(commit_data.hash);
- bucket_type &b = this->priv_buckets()[bucket_num];
+ size_type bucket_num = this->priv_hash_to_bucket(commit_data.hash);
+ bucket_type &b = this->priv_bucket_pointer()[bucket_num];
       this->priv_size_traits().increment();
- node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value));
+ node_ptr n = pointer_traits<node_ptr>::pointer_to(this->priv_value_to_node(value));
       node_functions_t::store_hash(n, commit_data.hash, store_hash_t());
       if(safemode_or_autounlink)
          BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
- priv_insertion_update_cache(bucket_num);
+ this->priv_insertion_update_cache(bucket_num);
       group_functions_t::insert_in_group(node_ptr(), n, optimize_multikey_t());
       return iterator(b.insert_after(b.before_begin(), *n), this);
    }
@@ -1443,9 +1443,9 @@
                               /// @endcond
                               )
    {
- priv_erase(i, disposer, optimize_multikey_t());
+ this->priv_erase(i, disposer, optimize_multikey_t());
       this->priv_size_traits().decrement();
- priv_erasure_update_cache();
+ this->priv_erasure_update_cache();
    }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1468,8 +1468,9 @@
          siterator first_local_it(b.slist_it());
          size_type first_bucket_num = this->priv_get_bucket_num(first_local_it);
 
+ const bucket_ptr bucket_pointer = this->priv_bucket_pointer();
          siterator before_first_local_it
- = priv_get_previous(priv_buckets()[first_bucket_num], first_local_it);
+ = this->priv_get_previous(bucket_pointer[first_bucket_num], first_local_it);
          size_type last_bucket_num;
          siterator last_local_it;
 
@@ -1477,14 +1478,14 @@
          //of the last bucket
          if(e == this->end()){
             last_bucket_num = this->bucket_count() - 1;
- last_local_it = priv_buckets()[last_bucket_num].end();
+ last_local_it = bucket_pointer[last_bucket_num].end();
          }
          else{
             last_local_it = e.slist_it();
             last_bucket_num = this->priv_get_bucket_num(last_local_it);
          }
- priv_erase_range(before_first_local_it, first_bucket_num, last_local_it, last_bucket_num, disposer);
- priv_erasure_update_cache(first_bucket_num, last_bucket_num);
+ this->priv_erase_range(before_first_local_it, first_bucket_num, last_local_it, last_bucket_num, disposer);
+ this->priv_erasure_update_cache(first_bucket_num, last_bucket_num);
       }
    }
 
@@ -1505,7 +1506,7 @@
    //! to the erased elements. No destructors are called.
    template<class Disposer>
    size_type erase_and_dispose(const_reference value, Disposer disposer)
- { return this->erase_and_dispose(value, priv_hasher(), priv_equal(), disposer); }
+ { return this->erase_and_dispose(value, this->priv_hasher(), this->priv_equal(), disposer); }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1531,7 +1532,7 @@
       siterator prev;
       siterator it =
          this->priv_find(key, hash_func, equal_func, bucket_num, h, prev);
- bool success = it != priv_invalid_local_it();
+ bool success = it != this->priv_invalid_local_it();
       size_type count(0);
       if(!success){
          return 0;
@@ -1539,15 +1540,15 @@
       else if(optimize_multikey){
          siterator last = bucket_type::s_iterator_to
             (*node_traits::get_next(group_functions_t::get_last_in_group
- (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
+ (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
          this->priv_erase_range_impl(bucket_num, prev, last, disposer, count);
       }
       else{
          //If found erase all equal values
- bucket_type &b = this->priv_buckets()[bucket_num];
+ bucket_type &b = this->priv_bucket_pointer()[bucket_num];
          for(siterator end = b.end(); it != end; ++count, ++it){
             slist_node_ptr n(it.pointed_node());
- const value_type &v = priv_value_from_slist_node(n);
+ const value_type &v = this->priv_value_from_slist_node(n);
             if(compare_hash){
                std::size_t vh = this->priv_stored_or_compute_hash(v, store_hash_t());
                if(h != vh || !equal_func(key, v)){
@@ -1561,7 +1562,7 @@
          }
          b.erase_after_and_dispose(prev, it, make_node_disposer(disposer));
       }
- priv_erasure_update_cache();
+ this->priv_erasure_update_cache();
       return count;
    }
 
@@ -1576,7 +1577,7 @@
    //! to the erased elements. No destructors are called.
    void clear()
    {
- priv_clear_buckets();
+ this->priv_clear_buckets();
       this->priv_size_traits().set_size(size_type(0));
    }
 
@@ -1596,13 +1597,13 @@
    {
       if(!constant_time_size || !this->empty()){
          size_type num_buckets = this->bucket_count();
- bucket_ptr b = this->priv_buckets();
+ bucket_ptr b = this->priv_bucket_pointer();
          for(; num_buckets--; ++b){
             b->clear_and_dispose(make_node_disposer(disposer));
          }
          this->priv_size_traits().set_size(size_type(0));
       }
- priv_initialize_cache();
+ this->priv_initialize_cache();
    }
 
    //! <b>Effects</b>: Returns the number of contained elements with the given value
@@ -1805,7 +1806,7 @@
    //! <b>Throws</b>: If the internal hash function throws.
    iterator iterator_to(reference value)
    {
- return iterator(bucket_type::s_iterator_to(priv_value_to_node(value)), this);
+ return iterator(bucket_type::s_iterator_to(this->priv_value_to_node(value)), this);
    }
 
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
@@ -1899,7 +1900,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    size_type bucket_count() const
- { return this->priv_buckets_len(); }
+ { return this->priv_bucket_count(); }
 
    //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
    //!
@@ -1909,7 +1910,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    size_type bucket_size(size_type n) const
- { return this->priv_buckets()[n].size(); }
+ { return this->priv_bucket_pointer()[n].size(); }
 
    //! <b>Effects</b>: Returns the index of the bucket in which elements
    //! with keys equivalent to k would be found, if any such element existed.
@@ -1936,7 +1937,7 @@
    //! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
    template<class KeyType, class KeyHasher>
    size_type bucket(const KeyType& k, const KeyHasher &hash_func) const
- { return priv_hash_to_bucket(hash_func(k)); }
+ { return this->priv_hash_to_bucket(hash_func(k)); }
 
    //! <b>Effects</b>: Returns the bucket array pointer passed in the constructor
    //! or the last rehash function.
@@ -1945,7 +1946,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    bucket_ptr bucket_pointer() const
- { return this->priv_buckets(); }
+ { return this->priv_bucket_pointer(); }
 
    //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
    //!
@@ -1959,7 +1960,7 @@
    //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
    //! containing all of the elements in the nth bucket.
    local_iterator begin(size_type n)
- { return local_iterator(this->priv_buckets()[n].begin(), this); }
+ { return local_iterator(this->priv_bucket_pointer()[n].begin(), this); }
 
    //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
    //!
@@ -1988,7 +1989,7 @@
    //! containing all of the elements in the nth bucket.
    const_local_iterator cbegin(size_type n) const
    {
- siterator sit = const_cast<bucket_type&>(this->priv_buckets()[n]).begin();
+ siterator sit = const_cast<bucket_type&>(this->priv_bucket_pointer()[n]).begin();
       return const_local_iterator(sit, this);
    }
 
@@ -2004,7 +2005,7 @@
    //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
    //! containing all of the elements in the nth bucket.
    local_iterator end(size_type n)
- { return local_iterator(this->priv_buckets()[n].end(), this); }
+ { return local_iterator(this->priv_bucket_pointer()[n].end(), this); }
 
    //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
    //!
@@ -2032,19 +2033,19 @@
    //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
    //! containing all of the elements in the nth bucket.
    const_local_iterator cend(size_type n) const
- { return const_local_iterator(const_cast<bucket_type&>(this->priv_buckets()[n]).end(), this); }
+ { return const_local_iterator(const_cast<bucket_type&>(this->priv_bucket_pointer()[n]).end(), this); }
 
- //! <b>Requires</b>: new_buckets must be a pointer to a new bucket array
- //! or the same as the old bucket array. new_size is the length of the
- //! the array pointed by new_buckets. If new_buckets == this->bucket_pointer()
- //! n can be bigger or smaller than this->bucket_count().
+ //! <b>Requires</b>: new_bucket_traits can hold a pointer to a new bucket array
+ //! or the same as the old bucket array with a different length. new_size is the length of the
+ //! the array pointed by new_buckets. If new_bucket_traits.bucket_begin() == this->bucket_pointer()
+ //! new_bucket_traits.bucket_count() can be bigger or smaller than this->bucket_count().
    //! 'new_bucket_traits' copy constructor should not throw.
    //!
- //! <b>Effects</b>: Updates the internal reference with the new bucket erases
+ //! <b>Effects</b>: Updates the internal reference with the new bucket, erases
    //! the values from the old bucket and inserts then in the new one.
    //! Bucket traits hold by *this is assigned from new_bucket_traits.
    //! If the container is configured as incremental<>, the split bucket is set
- //! to the new bucket_len().
+ //! to the new bucket_count().
    //!
    //! If store_hash option is true, this method does not use the hash function.
    //!
@@ -2053,27 +2054,27 @@
    //! <b>Throws</b>: If the hasher functor throws. Basic guarantee.
    void rehash(const bucket_traits &new_bucket_traits)
    {
- bucket_ptr new_buckets = new_bucket_traits.bucket_begin();
- size_type new_buckets_len = new_bucket_traits.bucket_count();
- bucket_ptr old_buckets = this->priv_buckets();
- size_type old_buckets_len = this->priv_buckets_len();
+ 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();
 
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
- (!power_2_buckets || (0 == (new_buckets_len & (new_buckets_len-1u))));
+ (!power_2_buckets || (0 == (new_bucket_count & (new_bucket_count-1u))));
 
- size_type n = priv_get_cache_bucket_num();
+ size_type n = this->priv_get_cache_bucket_num();
       const bool same_buffer = old_buckets == new_buckets;
       //If the new bucket length is a common factor
       //of the old one we can avoid hash calculations.
- const bool fast_shrink = (!incremental) && (old_buckets_len > new_buckets_len) &&
- (power_2_buckets ||(old_buckets_len % new_buckets_len) == 0);
+ const bool fast_shrink = (!incremental) && (old_bucket_count > new_bucket_count) &&
+ (power_2_buckets ||(old_bucket_count % new_bucket_count) == 0);
       //If we are shrinking the same bucket array and it's
       //is a fast shrink, just rehash the last nodes
- size_type new_first_bucket_num = new_buckets_len;
- if(same_buffer && fast_shrink && (n < new_buckets_len)){
- n = new_buckets_len;
- new_first_bucket_num = priv_get_cache_bucket_num();
+ size_type new_first_bucket_num = new_bucket_count;
+ if(same_buffer && fast_shrink && (n < new_bucket_count)){
+ n = new_bucket_count;
+ new_first_bucket_num = this->priv_get_cache_bucket_num();
       }
 
       //Anti-exception stuff: they destroy the elements if something goes wrong.
@@ -2084,19 +2085,19 @@
       bucket_type & newbuck = new_buckets[0];
       bucket_type & oldbuck = old_buckets[0];
       detail::exception_array_disposer<bucket_type, NodeDisposer, size_type>
- rollback1(newbuck, node_disp, new_buckets_len);
+ rollback1(newbuck, node_disp, new_bucket_count);
       detail::exception_array_disposer<bucket_type, NodeDisposer, size_type>
- rollback2(oldbuck, node_disp, old_buckets_len);
+ rollback2(oldbuck, node_disp, old_bucket_count);
 
       //Put size in a safe value for rollback exception
       size_type size_backup = this->priv_size_traits().get_size();
       this->priv_size_traits().set_size(0);
       //Put cache to safe position
- priv_initialize_cache();
- priv_insertion_update_cache(size_type(0u));
+ this->priv_initialize_cache();
+ this->priv_insertion_update_cache(size_type(0u));
 
       //Iterate through nodes
- for(; n < old_buckets_len; ++n){
+ for(; n < old_bucket_count; ++n){
          bucket_type &old_bucket = old_buckets[n];
 
          if(!fast_shrink){
@@ -2104,14 +2105,14 @@
             siterator end(old_bucket.end());
             siterator i(old_bucket.begin());
             for(;i != end; ++i){
- const value_type &v = priv_value_from_slist_node(i.pointed_node());
+ const value_type &v = this->priv_value_from_slist_node(i.pointed_node());
                const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
- const size_type new_n = priv_hash_to_bucket(hash_value, new_buckets_len, new_buckets_len);
+ const size_type new_n = this->priv_hash_to_bucket(hash_value, new_bucket_count, new_bucket_count);
                if(cache_begin && new_n < new_first_bucket_num)
                   new_first_bucket_num = new_n;
                siterator last = bucket_type::s_iterator_to
                   (*group_functions_t::get_last_in_group
- (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
+ (hashtable_impl::dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
                if(same_buffer && new_n == n){
                   before_i = last;
                }
@@ -2123,7 +2124,7 @@
             }
          }
          else{
- const size_type new_n = priv_hash_to_bucket(n, new_buckets_len, new_buckets_len);
+ const size_type new_n = this->priv_hash_to_bucket(n, new_bucket_count, new_bucket_count);
             if(cache_begin && new_n < new_first_bucket_num)
                new_first_bucket_num = new_n;
             bucket_type &new_b = new_buckets[new_n];
@@ -2131,16 +2132,16 @@
                new_b.splice_after( new_b.before_begin()
                                  , old_bucket
                                  , old_bucket.before_begin()
- , priv_get_last(old_bucket));
+ , hashtable_impl::priv_get_last(old_bucket));
             }
          }
       }
 
       this->priv_size_traits().set_size(size_backup);
- this->priv_split_traits().set_size(new_buckets_len);
+ this->priv_split_traits().set_size(new_bucket_count);
       this->priv_real_bucket_traits() = new_bucket_traits;
- priv_initialize_cache();
- priv_insertion_update_cache(new_first_bucket_num);
+ this->priv_initialize_cache();
+ this->priv_insertion_update_cache(new_first_bucket_num);
       rollback1.release();
       rollback2.release();
    }
@@ -2158,57 +2159,57 @@
    {
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
- size_type split_idx = priv_split_traits().get_size();
- size_type bucket_len = priv_buckets_len();
+ const size_type split_idx = this->priv_split_traits().get_size();
+ const size_type bucket_count = this->priv_bucket_count();
+ const bucket_ptr bucket_pointer = this->priv_bucket_pointer();
 
       if(grow){
          //Test if the split variable can be changed
- if(split_idx >= bucket_len)
+ if(split_idx >= bucket_count)
             return false;
 
- size_type bucket_len = priv_buckets_len();
- size_type bucket_to_rehash = split_idx - bucket_len/2;
- bucket_type &old_bucket = this->priv_buckets()[bucket_to_rehash];
+ const size_type bucket_to_rehash = split_idx - bucket_count/2;
+ bucket_type &old_bucket = bucket_pointer[bucket_to_rehash];
          siterator before_i(old_bucket.before_begin());
- siterator end(old_bucket.end());
+ const siterator end(old_bucket.end());
          siterator i(old_bucket.begin());
- priv_split_traits().increment();
+ this->priv_split_traits().increment();
 
          //Anti-exception stuff: if an exception is thrown while
          //moving elements from old_bucket to the target bucket, all moved
          //elements are moved back to the original one.
          detail::incremental_rehash_rollback<bucket_type, split_traits> rollback
- ( this->priv_buckets()[split_idx], old_bucket, priv_split_traits());
+ ( bucket_pointer[split_idx], old_bucket, this->priv_split_traits());
          for(;i != end; ++i){
- const value_type &v = priv_value_from_slist_node(i.pointed_node());
+ const value_type &v = this->priv_value_from_slist_node(i.pointed_node());
             const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
- const size_type new_n = priv_hash_to_bucket(hash_value);
+ const size_type new_n = this->priv_hash_to_bucket(hash_value);
             siterator last = bucket_type::s_iterator_to
                (*group_functions_t::get_last_in_group
- (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
+ (hashtable_impl::dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
             if(new_n == bucket_to_rehash){
                before_i = last;
             }
             else{
- bucket_type &new_b = this->priv_buckets()[new_n];
+ bucket_type &new_b = bucket_pointer[new_n];
                new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last);
             }
             i = before_i;
          }
          rollback.release();
- priv_erasure_update_cache();
+ this->priv_erasure_update_cache();
          return true;
       }
       else{
          //Test if the split variable can be changed
- if(split_idx <= bucket_len/2)
+ if(split_idx <= bucket_count/2)
             return false;
- const size_type target_bucket_num = split_idx - 1 - bucket_len/2;
- bucket_type &target_bucket = this->priv_buckets()[target_bucket_num];
- bucket_type &source_bucket = this->priv_buckets()[split_idx-1];
+ const size_type target_bucket_num = split_idx - 1 - bucket_count/2;
+ bucket_type &target_bucket = bucket_pointer[target_bucket_num];
+ bucket_type &source_bucket = bucket_pointer[split_idx-1];
          target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket);
- priv_split_traits().decrement();
- priv_insertion_update_cache(target_bucket_num);
+ this->priv_split_traits().decrement();
+ this->priv_insertion_update_cache(target_bucket_num);
          return true;
       }
    }
@@ -2231,7 +2232,7 @@
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
       size_type new_bucket_traits_size = new_bucket_traits.bucket_count();
- size_type cur_bucket_traits = this->priv_buckets_len();
+ size_type cur_bucket_traits = this->priv_bucket_count();
       if(new_bucket_traits_size/2 != cur_bucket_traits && new_bucket_traits_size != cur_bucket_traits/2){
          return false;
       }
@@ -2249,8 +2250,8 @@
             return false;
       }
 
- const size_type ini_n = priv_get_cache_bucket_num();
- const bucket_ptr old_buckets = this->priv_buckets();
+ const size_type ini_n = this->priv_get_cache_bucket_num();
+ const bucket_ptr old_buckets = this->priv_bucket_pointer();
       this->priv_real_bucket_traits() = new_bucket_traits;
       if(new_bucket_traits.bucket_begin() != old_buckets){
          for(size_type n = ini_n; n < split_idx; ++n){
@@ -2259,8 +2260,8 @@
             new_bucket.splice_after(new_bucket.cbefore_begin(), old_bucket);
          }
          //Put cache to safe position
- priv_initialize_cache();
- priv_insertion_update_cache(ini_n);
+ this->priv_initialize_cache();
+ this->priv_insertion_update_cache(ini_n);
       }
       return true;
    }
@@ -2321,22 +2322,22 @@
    private:
 
    std::size_t priv_hash_to_bucket(std::size_t hash_value) const
- { return priv_hash_to_bucket(hash_value, this->priv_real_bucket_traits().bucket_count(), priv_split_traits().get_size()); }
+ { return this->priv_hash_to_bucket(hash_value, this->priv_real_bucket_traits().bucket_count(), this->priv_split_traits().get_size()); }
 
- std::size_t priv_hash_to_bucket(std::size_t hash_value, std::size_t bucket_len, std::size_t split) const
+ std::size_t priv_hash_to_bucket(std::size_t hash_value, std::size_t bucket_count, std::size_t split) const
    {
- std::size_t bucket_number = priv_hash_to_bucket_impl(hash_value, bucket_len, power_2_buckets_t());
+ std::size_t bucket_number = hashtable_impl::priv_hash_to_bucket_impl(hash_value, bucket_count, power_2_buckets_t());
       if(incremental)
          if(bucket_number >= split)
- bucket_number -= bucket_len/2;
+ bucket_number -= bucket_count/2;
       return bucket_number;
    }
 
- std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::false_) const
- { return hash_value % bucket_len; }
+ static std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_count, detail::false_)
+ { return hash_value % bucket_count; }
 
- std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::true_) const
- { return hash_value & (bucket_len - 1); }
+ static std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_count, detail::true_)
+ { return hash_value & (bucket_count - 1); }
 
    const key_equal &priv_equal() const
    { return static_cast<const key_equal&>(this->data_.internal_.bucket_hash_equal_.get()); }
@@ -2351,10 +2352,10 @@
    { return data_; }
 
    value_type &priv_value_from_slist_node(slist_node_ptr n)
- { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); }
+ { return *this->get_real_value_traits().to_value_ptr(hashtable_impl::dcast_bucket_ptr(n)); }
 
    const value_type &priv_value_from_slist_node(slist_node_ptr n) const
- { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); }
+ { return *this->get_real_value_traits().to_value_ptr(hashtable_impl::dcast_bucket_ptr(n)); }
 
    const real_bucket_traits &priv_real_bucket_traits(detail::false_) const
    { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; }
@@ -2386,15 +2387,12 @@
    hasher &priv_hasher()
    { return static_cast<hasher&>(this->data_.internal_.bucket_hash_equal_.bucket_hash.get()); }
 
- bucket_ptr priv_buckets() const
+ bucket_ptr priv_bucket_pointer() const
    { return this->priv_real_bucket_traits().bucket_begin(); }
 
- size_type priv_buckets_len() const
+ size_type priv_bucket_count() const
    { return this->priv_real_bucket_traits().bucket_count(); }
 
- static node_ptr uncast(const const_node_ptr & ptr)
- { return node_ptr(const_cast<node*>(boost::intrusive::detail::to_raw_pointer(ptr))); }
-
    node &priv_value_to_node(value_type &v)
    { return *this->get_real_value_traits().to_node_ptr(v); }
 
@@ -2417,11 +2415,11 @@
    void priv_erase_range_impl
       (size_type bucket_num, siterator before_first_it, siterator end, Disposer disposer, size_type &num_erased)
    {
- const bucket_ptr buckets = priv_buckets();
+ const bucket_ptr buckets = this->priv_bucket_pointer();
       bucket_type &b = buckets[bucket_num];
 
       if(before_first_it == b.before_begin() && end == b.end()){
- priv_erase_range_impl(bucket_num, 1, disposer, num_erased);
+ this->priv_erase_range_impl(bucket_num, 1, disposer, num_erased);
       }
       else{
          num_erased = 0;
@@ -2429,7 +2427,7 @@
          ++to_erase;
          slist_node_ptr end_ptr = end.pointed_node();
          while(to_erase != end){
- group_functions_t::erase_from_group(end_ptr, dcast_bucket_ptr(to_erase.pointed_node()), optimize_multikey_t());
+ group_functions_t::erase_from_group(end_ptr, hashtable_impl::dcast_bucket_ptr(to_erase.pointed_node()), optimize_multikey_t());
             to_erase = b.erase_after_and_dispose(before_first_it, make_node_disposer(disposer));
             ++num_erased;
          }
@@ -2442,7 +2440,7 @@
       (size_type first_bucket_num, size_type num_buckets, Disposer disposer, size_type &num_erased)
    {
       //Now fully clear the intermediate buckets
- const bucket_ptr buckets = priv_buckets();
+ const bucket_ptr buckets = this->priv_bucket_pointer();
       num_erased = 0;
       for(size_type i = first_bucket_num; i < (num_buckets + first_bucket_num); ++i){
          bucket_type &b = buckets[i];
@@ -2451,7 +2449,7 @@
          ++nxt;
          siterator end(b.end());
          while(nxt != end){
- group_functions_t::init_group(dcast_bucket_ptr(nxt.pointed_node()), optimize_multikey_t());
+ group_functions_t::init_group(hashtable_impl::dcast_bucket_ptr(nxt.pointed_node()), optimize_multikey_t());
             nxt = b.erase_after_and_dispose
                (b_begin, make_node_disposer(disposer));
             this->priv_size_traits().decrement();
@@ -2467,14 +2465,14 @@
    {
       size_type num_erased;
       if (first_bucket == last_bucket){
- priv_erase_range_impl(first_bucket, before_first_it, last_it, disposer, num_erased);
+ this->priv_erase_range_impl(first_bucket, before_first_it, last_it, disposer, num_erased);
       }
       else {
- bucket_type *b = (&this->priv_buckets()[0]);
- priv_erase_range_impl(first_bucket, before_first_it, b[first_bucket].end(), disposer, num_erased);
+ bucket_type *b = (&this->priv_bucket_pointer()[0]);
+ this->priv_erase_range_impl(first_bucket, before_first_it, b[first_bucket].end(), disposer, num_erased);
          if(size_type n = (last_bucket - first_bucket - 1))
- priv_erase_range_impl(first_bucket + 1, n, disposer, num_erased);
- priv_erase_range_impl(last_bucket, b[last_bucket].before_begin(), last_it, disposer, num_erased);
+ this->priv_erase_range_impl(first_bucket + 1, n, disposer, num_erased);
+ this->priv_erase_range_impl(last_bucket, b[last_bucket].before_begin(), last_it, disposer, num_erased);
       }
    }
 
@@ -2485,10 +2483,10 @@
    { return node_traits::get_hash(this->get_real_value_traits().to_node_ptr(v)); }
 
    std::size_t priv_stored_or_compute_hash(const value_type &v, detail::false_) const
- { return priv_hasher()(v); }
+ { return this->priv_hasher()(v); }
 
    std::size_t priv_stored_hash(slist_node_ptr n, detail::true_) const
- { return node_traits::get_hash(dcast_bucket_ptr(n)); }
+ { return node_traits::get_hash(hashtable_impl::dcast_bucket_ptr(n)); }
 
    std::size_t priv_stored_hash(slist_node_ptr, detail::false_) const
    {
@@ -2501,7 +2499,7 @@
    {
       siterator it(b.begin()), itend(b.end());
       while(it != itend){
- node_ptr to_erase(dcast_bucket_ptr(it.pointed_node()));
+ node_ptr to_erase(hashtable_impl::dcast_bucket_ptr(it.pointed_node()));
          ++it;
          group_algorithms::init(to_erase);
       }
@@ -2511,7 +2509,7 @@
    {}
 
    std::size_t priv_get_bucket_num(siterator it)
- { return priv_get_bucket_num_hash_dispatch(it, store_hash_t()); }
+ { return this->priv_get_bucket_num_hash_dispatch(it, store_hash_t()); }
 
    std::size_t priv_get_bucket_num_hash_dispatch(siterator it, detail::true_)
    {
@@ -2520,15 +2518,15 @@
    }
 
    std::size_t priv_get_bucket_num_hash_dispatch(siterator it, detail::false_)
- { return priv_get_bucket_num_no_hash_store(it, optimize_multikey_t()); }
+ { return this->priv_get_bucket_num_no_hash_store(it, optimize_multikey_t()); }
 
    std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::true_)
    {
- bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1);
+ const bucket_ptr f(this->priv_bucket_pointer()), l(f + this->priv_bucket_count() - 1);
       slist_node_ptr bb = group_functions_t::get_bucket_before_begin
          ( f->end().pointed_node()
          , l->end().pointed_node()
- , dcast_bucket_ptr(it.pointed_node()));
+ , hashtable_impl::dcast_bucket_ptr(it.pointed_node()));
       //Now get the bucket_impl from the iterator
       const bucket_type &b = static_cast<const bucket_type&>
          (bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb)));
@@ -2538,7 +2536,7 @@
 
    std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_)
    {
- bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1);
+ bucket_ptr f(this->priv_bucket_pointer()), l(f + this->priv_bucket_count() - 1);
       slist_node_ptr first_ptr(f->cend().pointed_node())
                    , last_ptr(l->cend().pointed_node());
 
@@ -2557,12 +2555,12 @@
 
    siterator priv_get_previous
       (bucket_type &b, siterator i)
- { return priv_get_previous(b, i, optimize_multikey_t()); }
+ { return this->priv_get_previous(b, i, optimize_multikey_t()); }
 
    siterator priv_get_previous
       (bucket_type &b, siterator i, detail::true_)
    {
- node_ptr elem(dcast_bucket_ptr(i.pointed_node()));
+ node_ptr elem(hashtable_impl::dcast_bucket_ptr(i.pointed_node()));
       node_ptr prev_in_group(group_traits::get_next(elem));
       bool first_in_group = node_traits::get_next(prev_in_group) != elem;
       typename bucket_type::node &n = first_in_group
@@ -2577,7 +2575,7 @@
    { return b.previous(i); }
 
    static siterator priv_get_last(bucket_type &b)
- { return priv_get_last(b, optimize_multikey_t()); }
+ { return hashtable_impl::priv_get_last(b, optimize_multikey_t()); }
 
    static siterator priv_get_last(bucket_type &b, detail::true_)
    {
@@ -2585,11 +2583,11 @@
       //This requires checking the first node of the next group or
       //the bucket node.
       slist_node_ptr end_ptr(b.end().pointed_node());
- node_ptr possible_end(node_traits::get_next( dcast_bucket_ptr(end_ptr)));
+ node_ptr possible_end(node_traits::get_next( hashtable_impl::dcast_bucket_ptr(end_ptr)));
       node_ptr last_node_group(possible_end);
 
       while(end_ptr != possible_end){
- last_node_group = group_traits::get_next(dcast_bucket_ptr(possible_end));
+ last_node_group = group_traits::get_next(hashtable_impl::dcast_bucket_ptr(possible_end));
          possible_end = node_traits::get_next(last_node_group);
       }
       return bucket_type::s_iterator_to(*last_node_group);
@@ -2597,87 +2595,7 @@
 
    static siterator priv_get_last(bucket_type &b, detail::false_)
    { return b.previous(b.end()); }
-/*
- siterator priv_get_previous_and_next_in_group
- (siterator i, node_ptr &nxt_in_group)
- {
- siterator prev;
- node_ptr elem(dcast_bucket_ptr(i.pointed_node()));
- bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1);
-
- slist_node_ptr first_end_ptr(f->cend().pointed_node());
- slist_node_ptr last_end_ptr (l->cend().pointed_node());
-
- node_ptr nxt(node_traits::get_next(elem));
- node_ptr prev_in_group(group_traits::get_next(elem));
- bool last_in_group = (first_end_ptr <= nxt && nxt <= last_end_ptr) ||
- (group_traits::get_next(nxt) != elem);
- bool first_in_group = node_traits::get_next(prev_in_group) != elem;
 
- if(first_in_group){
- node_ptr start_pos;
- if(last_in_group){
- start_pos = elem;
- nxt_in_group = node_ptr();
- }
- else{
- start_pos = prev_in_group;
- nxt_in_group = node_traits::get_next(elem);
- }
- slist_node_ptr bucket_node;
- if(store_hash){
- bucket_node = this->priv_buckets()
- [this->priv_hash_to_bucket
- (this->priv_stored_hash(elem, store_hash_t()))
- ].before_begin().pointed_node();
- }
- else{
- bucket_node = group_functions_t::get_bucket_before_begin
- (first_end_ptr, last_end_ptr, start_pos);
- }
- prev = bucket_type::s_iterator_to
- (*group_functions_t::get_prev_to_first_in_group(bucket_node, elem));
- }
- else{
- if(last_in_group){
- nxt_in_group = group_functions_t::get_first_in_group_of_last_in_group(elem);
- }
- else{
- nxt_in_group = node_traits::get_next(elem);
- }
- prev = bucket_type::s_iterator_to(*group_traits::get_next(elem));
- }
- return prev;
- }
-*/
-
-/*
- template<class Disposer>
- void priv_erase(const_iterator i, Disposer disposer, detail::true_)
- {
- siterator elem(i.slist_it());
- node_ptr nxt_in_group;
- siterator prev = priv_get_previous_and_next_in_group(elem, nxt_in_group);
- bucket_type::s_erase_after_and_dispose(prev, make_node_disposer(disposer));
- if(nxt_in_group)
- group_algorithms::unlink_after(nxt_in_group);
- if(safemode_or_autounlink)
- group_algorithms::init(dcast_bucket_ptr(elem.pointed_node()));
- }
-*/
-
-/*
- if(store_hash){
- bucket_node = this->priv_buckets()
- [this->priv_hash_to_bucket
- (this->priv_stored_hash(elem, store_hash_t()))
- ].before_begin().pointed_node();
- }
- else{
- bucket_node = group_functions_t::get_bucket_before_begin
- (first_end_ptr, last_end_ptr, start_pos);
- }
-*/
    template<class Disposer>
    void priv_erase(const_iterator i, Disposer disposer, detail::true_)
    {
@@ -2685,14 +2603,14 @@
       slist_node_ptr f_bucket_end, l_bucket_end;
       if(store_hash){
          f_bucket_end = l_bucket_end =
- (this->priv_buckets()
+ (this->priv_bucket_pointer()
             [this->priv_hash_to_bucket
                (this->priv_stored_hash(elem, store_hash_t()))
             ]).before_begin().pointed_node();
       }
       else{
- f_bucket_end = this->priv_buckets()->cend().pointed_node();
- l_bucket_end = f_bucket_end + priv_buckets_len() - 1;
+ f_bucket_end = this->priv_bucket_pointer()->cend().pointed_node();
+ l_bucket_end = f_bucket_end + this->priv_bucket_count() - 1;
       }
       node_ptr nxt_in_group;
       siterator prev = bucket_type::s_iterator_to
@@ -2703,15 +2621,15 @@
       if(nxt_in_group)
          group_algorithms::unlink_after(nxt_in_group);
       if(safemode_or_autounlink)
- group_algorithms::init(dcast_bucket_ptr(elem));
+ group_algorithms::init(hashtable_impl::dcast_bucket_ptr(elem));
    }
 
    template <class Disposer>
    void priv_erase(const_iterator i, Disposer disposer, detail::false_)
    {
       siterator to_erase(i.slist_it());
- bucket_type &b = this->priv_buckets()[this->priv_get_bucket_num(to_erase)];
- siterator prev(priv_get_previous(b, to_erase));
+ bucket_type &b = this->priv_bucket_pointer()[this->priv_get_bucket_num(to_erase)];
+ siterator prev(this->priv_get_previous(b, to_erase));
       b.erase_after_and_dispose(prev, make_node_disposer(disposer));
    }
 
@@ -2722,28 +2640,28 @@
    }
 
    siterator priv_invalid_local_it() const
- { return priv_invalid_bucket()->end(); }
+ { return this->priv_invalid_bucket()->end(); }
 
    siterator priv_begin() const
- { return priv_begin(cache_begin_t()); }
+ { return this->priv_begin(cache_begin_t()); }
 
    siterator priv_begin(detail::false_) const
    {
       size_type n = 0;
- size_type buckets_len = this->priv_buckets_len();
- for (n = 0; n < buckets_len; ++n){
- bucket_type &b = this->priv_buckets()[n];
+ size_type bucket_count = this->priv_bucket_count();
+ for (n = 0; n < bucket_count; ++n){
+ bucket_type &b = this->priv_bucket_pointer()[n];
          if(!b.empty()){
             return b.begin();
          }
       }
- return priv_invalid_local_it();
+ return this->priv_invalid_local_it();
    }
 
    siterator priv_begin(detail::true_) const
    {
- if(this->data_.internal_.bucket_hash_equal_.cached_begin_ == priv_invalid_bucket()){
- return priv_invalid_local_it();
+ if(this->data_.internal_.bucket_hash_equal_.cached_begin_ == this->priv_invalid_bucket()){
+ return this->priv_invalid_local_it();
       }
       else{
          return this->data_.internal_.bucket_hash_equal_.cached_begin_->begin();
@@ -2751,20 +2669,20 @@
    }
 
    void priv_initialize_cache()
- { priv_initialize_cache(cache_begin_t()); }
+ { this->priv_initialize_cache(cache_begin_t()); }
 
    void priv_initialize_cache(detail::true_)
- { this->data_.internal_.bucket_hash_equal_.cached_begin_ = priv_invalid_bucket(); }
+ { this->data_.internal_.bucket_hash_equal_.cached_begin_ = this->priv_invalid_bucket(); }
 
    void priv_initialize_cache(detail::false_)
    {}
 
    void priv_insertion_update_cache(size_type insertion_bucket)
- { priv_insertion_update_cache(insertion_bucket, cache_begin_t()); }
+ { this->priv_insertion_update_cache(insertion_bucket, cache_begin_t()); }
 
    void priv_insertion_update_cache(size_type insertion_bucket, detail::true_)
    {
- bucket_ptr p = priv_buckets() + insertion_bucket;
+ bucket_ptr p = this->priv_bucket_pointer() + insertion_bucket;
       if(p < this->data_.internal_.bucket_hash_equal_.cached_begin_){
          this->data_.internal_.bucket_hash_equal_.cached_begin_ = p;
       }
@@ -2774,16 +2692,16 @@
    {}
 
    void priv_erasure_update_cache(size_type first_bucket, size_type last_bucket)
- { priv_erasure_update_cache(first_bucket, last_bucket, cache_begin_t()); }
+ { this->priv_erasure_update_cache(first_bucket, last_bucket, cache_begin_t()); }
 
    void priv_erasure_update_cache(size_type first_bucket_num, size_type last_bucket_num, detail::true_)
    {
       //If the last bucket is the end, the cache must be updated
       //to the last position if all
- if(priv_get_cache_bucket_num() == first_bucket_num &&
- priv_buckets()[first_bucket_num].empty() ){
- priv_set_cache(priv_buckets() + last_bucket_num);
- priv_erasure_update_cache();
+ if(this->priv_get_cache_bucket_num() == first_bucket_num &&
+ this->priv_bucket_pointer()[first_bucket_num].empty() ){
+ this->priv_set_cache(this->priv_bucket_pointer() + last_bucket_num);
+ this->priv_erasure_update_cache();
       }
    }
 
@@ -2791,23 +2709,23 @@
    {}
 
    void priv_erasure_update_cache()
- { priv_erasure_update_cache(cache_begin_t()); }
+ { this->priv_erasure_update_cache(cache_begin_t()); }
 
    void priv_erasure_update_cache(detail::true_)
    {
       if(constant_time_size && !size()){
- priv_initialize_cache();
+ this->priv_initialize_cache();
       }
       else{
- size_type current_n = this->data_.internal_.bucket_hash_equal_.cached_begin_ - priv_buckets();
- for( const size_type num_buckets = this->priv_buckets_len()
+ size_type current_n = this->data_.internal_.bucket_hash_equal_.cached_begin_ - this->priv_bucket_pointer();
+ for( const size_type num_buckets = this->priv_bucket_count()
             ; current_n < num_buckets
             ; ++current_n, ++this->data_.internal_.bucket_hash_equal_.cached_begin_){
             if(!this->data_.internal_.bucket_hash_equal_.cached_begin_->empty()){
                return;
             }
          }
- priv_initialize_cache();
+ this->priv_initialize_cache();
       }
    }
 
@@ -2824,22 +2742,22 @@
    {}
 
    bucket_ptr priv_get_cache()
- { return priv_get_cache(cache_begin_t()); }
+ { return this->priv_get_cache(cache_begin_t()); }
 
    bucket_ptr priv_get_cache(detail::true_)
    { return this->data_.internal_.bucket_hash_equal_.cached_begin_; }
 
    bucket_ptr priv_get_cache(detail::false_)
- { return this->priv_buckets(); }
+ { return this->priv_bucket_pointer(); }
 
    void priv_set_cache(const bucket_ptr &p)
    { this->data_.internal_.bucket_hash_equal_.set_cache(p); }
 
    size_type priv_get_cache_bucket_num()
- { return priv_get_cache_bucket_num(cache_begin_t()); }
+ { return this->priv_get_cache_bucket_num(cache_begin_t()); }
 
    size_type priv_get_cache_bucket_num(detail::true_)
- { return this->data_.internal_.bucket_hash_equal_.cached_begin_ - this->priv_buckets(); }
+ { return this->data_.internal_.bucket_hash_equal_.cached_begin_ - this->priv_bucket_pointer(); }
 
    size_type priv_get_cache_bucket_num(detail::false_)
    { return 0u; }
@@ -2847,25 +2765,25 @@
    void priv_clear_buckets()
    {
       this->priv_clear_buckets
- ( priv_get_cache()
- , this->priv_buckets_len() - (priv_get_cache() - priv_buckets()));
+ ( this->priv_get_cache()
+ , this->priv_bucket_count() - (this->priv_get_cache() - this->priv_bucket_pointer()));
    }
 
    void priv_initialize_buckets()
- { this->priv_clear_buckets(priv_buckets(), this->priv_buckets_len()); }
+ { this->priv_clear_buckets(this->priv_bucket_pointer(), this->priv_bucket_count()); }
 
- void priv_clear_buckets(bucket_ptr buckets_ptr, size_type buckets_len)
+ void priv_clear_buckets(bucket_ptr buckets_ptr, size_type bucket_count)
    {
- for(; buckets_len--; ++buckets_ptr){
+ for(; bucket_count--; ++buckets_ptr){
          if(safemode_or_autounlink){
- priv_clear_group_nodes(*buckets_ptr, optimize_multikey_t());
+ hashtable_impl::priv_clear_group_nodes(*buckets_ptr, optimize_multikey_t());
             buckets_ptr->clear_and_dispose(detail::init_disposer<node_algorithms>());
          }
          else{
             buckets_ptr->clear();
          }
       }
- priv_initialize_cache();
+ this->priv_initialize_cache();
    }
 
    template<class KeyType, class KeyHasher, class KeyValueEqual>
@@ -2874,25 +2792,25 @@
       , KeyValueEqual equal_func, size_type &bucket_number, std::size_t &h, siterator &previt) const
    {
       h = hash_func(key);
- return priv_find_with_hash(key, equal_func, bucket_number, h, previt);
+ return this->priv_find_with_hash(key, equal_func, bucket_number, h, previt);
    }
 
    template<class KeyType, class KeyValueEqual>
    siterator priv_find_with_hash
       ( const KeyType &key, KeyValueEqual equal_func, size_type &bucket_number, const std::size_t h, siterator &previt) const
    {
- bucket_number = priv_hash_to_bucket(h);
- bucket_type &b = this->priv_buckets()[bucket_number];
+ bucket_number = this->priv_hash_to_bucket(h);
+ bucket_type &b = this->priv_bucket_pointer()[bucket_number];
       previt = b.before_begin();
       if(constant_time_size && this->empty()){
- return priv_invalid_local_it();
+ return this->priv_invalid_local_it();
       }
 
       siterator it = previt;
       ++it;
 
       while(it != b.end()){
- const value_type &v = priv_value_from_slist_node(it.pointed_node());
+ const value_type &v = this->priv_value_from_slist_node(it.pointed_node());
          if(compare_hash){
             std::size_t vh = this->priv_stored_or_compute_hash(v, store_hash_t());
             if(h == vh && equal_func(key, v)){
@@ -2905,7 +2823,7 @@
          if(optimize_multikey){
             previt = bucket_type::s_iterator_to
                (*group_functions_t::get_last_in_group
- (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t()));
+ (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t()));
             it = previt;
          }
          else{
@@ -2914,7 +2832,7 @@
          ++it;
       }
       previt = b.before_begin();
- return priv_invalid_local_it();
+ return this->priv_invalid_local_it();
    }
 
    iterator priv_insert_equal_with_hash(reference value, std::size_t hash_value)
@@ -2923,18 +2841,18 @@
       siterator prev;
       siterator it = this->priv_find_with_hash
          (value, this->priv_equal(), bucket_num, hash_value, prev);
- return priv_insert_equal_find(value, bucket_num, hash_value, it);
+ return this->priv_insert_equal_find(value, bucket_num, hash_value, it);
    }
 
    iterator priv_insert_equal_find(reference value, size_type bucket_num, std::size_t hash_value, siterator it)
    {
- bucket_type &b = this->priv_buckets()[bucket_num];
- bool found_equal = it != priv_invalid_local_it();
+ bucket_type &b = this->priv_bucket_pointer()[bucket_num];
+ bool found_equal = it != this->priv_invalid_local_it();
       if(!found_equal){
          it = b.before_begin();
       }
       //Now store hash if needed
- node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value));
+ node_ptr n = pointer_traits<node_ptr>::pointer_to(this->priv_value_to_node(value));
       node_functions_t::store_hash(n, hash_value, store_hash_t());
       //Checks for some modes
       if(safemode_or_autounlink)
@@ -2942,11 +2860,11 @@
       //Shorcut for optimize_multikey cases
       if(optimize_multikey){
          node_ptr first_in_group = found_equal ?
- dcast_bucket_ptr(it.pointed_node()) : node_ptr();
+ hashtable_impl::dcast_bucket_ptr(it.pointed_node()) : node_ptr();
          group_functions_t::insert_in_group(first_in_group, n, optimize_multikey_t());
       }
       //Update cache and increment size if needed
- priv_insertion_update_cache(bucket_num);
+ this->priv_insertion_update_cache(bucket_num);
       this->priv_size_traits().increment();
       //Insert the element in the bucket after it
       return iterator(b.insert_after(it, *n), this);
@@ -2966,20 +2884,20 @@
       siterator prev;
       //Let's see if the element is present
       std::pair<siterator, siterator> to_return
- ( priv_find(key, hash_func, equal_func, bucket_number_first, h, prev)
- , priv_invalid_local_it());
+ ( this->priv_find(key, hash_func, equal_func, bucket_number_first, h, prev)
+ , this->priv_invalid_local_it());
       if(to_return.first == to_return.second){
          bucket_number_second = bucket_number_first;
          return to_return;
       }
       //If it's present, find the first that it's not equal in
       //the same bucket
- bucket_type &b = this->priv_buckets()[bucket_number_first];
+ bucket_type &b = this->priv_bucket_pointer()[bucket_number_first];
       siterator it = to_return.first;
       if(optimize_multikey){
          to_return.second = bucket_type::s_iterator_to
             (*node_traits::get_next(group_functions_t::get_last_in_group
- (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
+ (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
          count = std::distance(it, to_return.second);
          if(to_return.second != b.end()){
             bucket_number_second = bucket_number_first;
@@ -2990,7 +2908,7 @@
          ++count;
          ++it;
          while(it != b.end()){
- const value_type &v = priv_value_from_slist_node(it.pointed_node());
+ const value_type &v = this->priv_value_from_slist_node(it.pointed_node());
             if(compare_hash){
                std::size_t hv = this->priv_stored_or_compute_hash(v, store_hash_t());
                if(hv != h || !equal_func(key, v)){
@@ -3011,9 +2929,9 @@
 
       //If we reached the end, find the first, non-empty bucket
       for(bucket_number_second = bucket_number_first+1
- ; bucket_number_second != this->priv_buckets_len()
+ ; bucket_number_second != this->priv_bucket_count()
          ; ++bucket_number_second){
- bucket_type &b = this->priv_buckets()[bucket_number_second];
+ bucket_type &b = this->priv_bucket_pointer()[bucket_number_second];
          if(!b.empty()){
             to_return.second = b.begin();
             return to_return;
@@ -3021,7 +2939,7 @@
       }
 
       //Otherwise, return the end node
- to_return.second = priv_invalid_local_it();
+ to_return.second = this->priv_invalid_local_it();
       return to_return;
    }
    /// @endcond
@@ -3055,7 +2973,9 @@
    typedef typename detail::get_value_traits
       <T, typename packed_options::value_traits>::type value_traits;
    static const bool external_value_traits =
- detail::external_value_traits_is_true<value_traits>::value;
+ detail::external_value_traits_bool_is_true<value_traits>::value;/*
+ static const bool resizable_bucket_traits =
+ detail::resizable_bool_is_true<bucket_traits_traits>::value;*/
    typedef typename detail::eval_if_c
       < external_value_traits
       , detail::eval_value_traits<value_traits>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk