feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Unordered: Call policy functions as static functions.

Browse Source 
[SVN r77831]
This commit is contained in:
Daniel James
2012-04-08 15:28:26 +00:00
parent 9f199eaa23
commit 4e759b4444
6 changed files with 55 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/boost/unordered/detail/buckets.hpp
View File

@ -280,6 +280,7 @@ namespace boost { namespace unordered { namespace detail {
typedef boost::unordered::detail::allocator_traits<A> traits; typedef boost::unordered::detail::allocator_traits<A> traits;
typedef typename traits::value_type value_type; typedef typename traits::value_type value_type;
typedef Policy policy;
typedef Node node; typedef Node node;
typedef Bucket bucket; typedef Bucket bucket;
typedef typename boost::unordered::detail::rebind_wrap<A, node>::type typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
@ -334,7 +335,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t max_bucket_count() const std::size_t max_bucket_count() const
{ {
// -1 to account for the start bucket. // -1 to account for the start bucket.
return this->prev_bucket_count( return policy::prev_bucket_count(
bucket_allocator_traits::max_size(bucket_alloc()) - 1); bucket_allocator_traits::max_size(bucket_alloc()) - 1);
} }
@ -379,7 +380,8 @@ namespace boost { namespace unordered { namespace detail {
if (!ptr) return 0; if (!ptr) return 0;
std::size_t count = 0; std::size_t count = 0;
while(ptr && this->to_bucket(this->bucket_count_, ptr->hash_) == index) while(ptr &&
policy::to_bucket(this->bucket_count_, ptr->hash_) == index)
{ {
++count; ++count;
ptr = static_cast<node_pointer>(ptr->next_); ptr = static_cast<node_pointer>(ptr->next_);
@ -574,7 +576,7 @@ namespace boost { namespace unordered { namespace detail {
else else
{ {
bucket_pointer next_bucket = this->get_bucket( bucket_pointer next_bucket = this->get_bucket(
this->to_bucket(this->bucket_count_, next->hash_)); policy::to_bucket(this->bucket_count_, next->hash_));
if (next_bucket != bucket) if (next_bucket != bucket)
{ {
@ -600,7 +602,7 @@ namespace boost { namespace unordered { namespace detail {
if (n == end) return; if (n == end) return;
std::size_t new_bucket_index = std::size_t new_bucket_index =
this->to_bucket(this->bucket_count_, n->hash_); policy::to_bucket(this->bucket_count_, n->hash_);
if (bucket_index != new_bucket_index) { if (bucket_index != new_bucket_index) {
bucket_index = new_bucket_index; bucket_index = new_bucket_index;
break; break;
@ -616,7 +618,7 @@ namespace boost { namespace unordered { namespace detail {
if (n == end) break; if (n == end) break;
std::size_t new_bucket_index = std::size_t new_bucket_index =
this->to_bucket(this->bucket_count_, n->hash_); policy::to_bucket(this->bucket_count_, n->hash_);
if (bucket_index != new_bucket_index) { if (bucket_index != new_bucket_index) {
bucket_index = new_bucket_index; bucket_index = new_bucket_index;
this->get_bucket(bucket_index)->next_ = previous_pointer(); this->get_bucket(bucket_index)->next_ = previous_pointer();
@ -625,7 +627,8 @@ namespace boost { namespace unordered { namespace detail {
// Finally fix the bucket containing the trailing node. // Finally fix the bucket containing the trailing node.
if (n) { if (n) {
this->get_bucket(this->to_bucket(this->bucket_count_, n->hash_))->next_ this->get_bucket(
policy::to_bucket(this->bucket_count_, n->hash_))->next_
= prev; = prev;
} }
} }

30
include/boost/unordered/detail/equivalent.hpp
View File

@ -173,6 +173,7 @@ namespace boost { namespace unordered { namespace detail {
typedef typename table::value_type value_type; typedef typename table::value_type value_type;
typedef typename table::bucket bucket; typedef typename table::bucket bucket;
typedef typename table::buckets buckets; typedef typename table::buckets buckets;
typedef typename table::policy policy;
typedef typename table::node_pointer node_pointer; typedef typename table::node_pointer node_pointer;
typedef typename table::node_allocator node_allocator; typedef typename table::node_allocator node_allocator;
typedef typename table::node_allocator_traits node_allocator_traits; typedef typename table::node_allocator_traits node_allocator_traits;
@ -223,7 +224,8 @@ namespace boost { namespace unordered { namespace detail {
Key const& k, Key const& k,
Pred const& eq) const Pred const& eq) const
{ {
std::size_t bucket_index = this->to_bucket(this->bucket_count_, hash); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, hash);
node_pointer n = this->get_start(bucket_index); node_pointer n = this->get_start(bucket_index);
for (;;) for (;;)
@ -238,7 +240,8 @@ namespace boost { namespace unordered { namespace detail {
} }
else else
{ {
if (this->to_bucket(this->bucket_count_, node_hash) != bucket_index) if (policy::to_bucket(this->bucket_count_, node_hash)
!= bucket_index)
return node_pointer(); return node_pointer();
} }
@ -401,23 +404,25 @@ namespace boost { namespace unordered { namespace detail {
if(pos) { if(pos) {
this->add_after_node(n, pos); this->add_after_node(n, pos);
if (n->next_) { if (n->next_) {
std::size_t next_bucket = this->to_bucket( std::size_t next_bucket = policy::to_bucket(
this->bucket_count_, this->bucket_count_,
static_cast<node_pointer>(n->next_)->hash_); static_cast<node_pointer>(n->next_)->hash_);
if (next_bucket != this->to_bucket(this->bucket_count_, hash)) { if (next_bucket !=
policy::to_bucket(this->bucket_count_, hash)) {
this->get_bucket(next_bucket)->next_ = n; this->get_bucket(next_bucket)->next_ = n;
} }
} }
} }
else { else {
bucket_pointer b = this->get_bucket(this->to_bucket(this->bucket_count_, hash)); bucket_pointer b = this->get_bucket(
policy::to_bucket(this->bucket_count_, hash));
if (!b->next_) if (!b->next_)
{ {
previous_pointer start_node = this->get_previous_start(); previous_pointer start_node = this->get_previous_start();
if (start_node->next_) { if (start_node->next_) {
this->get_bucket(this->to_bucket(this->bucket_count_, this->get_bucket(policy::to_bucket(this->bucket_count_,
static_cast<node_pointer>(start_node->next_)->hash_ static_cast<node_pointer>(start_node->next_)->hash_
))->next_ = n; ))->next_ = n;
} }
@ -528,7 +533,8 @@ namespace boost { namespace unordered { namespace detail {
if(!this->size_) return 0; if(!this->size_) return 0;
std::size_t hash = this->hash(k); std::size_t hash = this->hash(k);
std::size_t bucket_index = this->to_bucket(this->bucket_count_, hash); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, hash);
bucket_pointer bucket = this->get_bucket(bucket_index); bucket_pointer bucket = this->get_bucket(bucket_index);
previous_pointer prev = bucket->next_; previous_pointer prev = bucket->next_;
@ -539,7 +545,8 @@ namespace boost { namespace unordered { namespace detail {
if (!prev->next_) return 0; if (!prev->next_) return 0;
std::size_t node_hash = std::size_t node_hash =
static_cast<node_pointer>(prev->next_)->hash_; static_cast<node_pointer>(prev->next_)->hash_;
if (this->to_bucket(this->bucket_count_, node_hash) != bucket_index) if (policy::to_bucket(this->bucket_count_, node_hash)
!= bucket_index)
return 0; return 0;
if (node_hash == hash && if (node_hash == hash &&
this->key_eq()(k, this->get_key( this->key_eq()(k, this->get_key(
@ -564,7 +571,7 @@ namespace boost { namespace unordered { namespace detail {
node_pointer next = static_cast<node_pointer>(r->next_); node_pointer next = static_cast<node_pointer>(r->next_);
bucket_pointer bucket = this->get_bucket( bucket_pointer bucket = this->get_bucket(
this->to_bucket(this->bucket_count_, r->hash_)); policy::to_bucket(this->bucket_count_, r->hash_));
previous_pointer prev = unlink_node(*bucket, r); previous_pointer prev = unlink_node(*bucket, r);
this->fix_buckets(bucket, prev, next); this->fix_buckets(bucket, prev, next);
@ -578,7 +585,8 @@ namespace boost { namespace unordered { namespace detail {
{ {
if (r1 == r2) return r2; if (r1 == r2) return r2;
std::size_t bucket_index = this->to_bucket(this->bucket_count_, r1->hash_); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, r1->hash_);
previous_pointer prev = unlink_nodes( previous_pointer prev = unlink_nodes(
*this->get_bucket(bucket_index), r1, r2); *this->get_bucket(bucket_index), r1, r2);
this->fix_buckets_range(bucket_index, prev, r1, r2); this->fix_buckets_range(bucket_index, prev, r1, r2);
@ -813,7 +821,7 @@ namespace boost { namespace unordered { namespace detail {
static previous_pointer place_in_bucket(buckets& dst, static previous_pointer place_in_bucket(buckets& dst,
previous_pointer prev, node_pointer end) previous_pointer prev, node_pointer end)
{ {
bucket_pointer b = dst.get_bucket(dst.to_bucket( bucket_pointer b = dst.get_bucket(policy::to_bucket(
dst.bucket_count_, end->hash_)); dst.bucket_count_, end->hash_));
if (!b->next_) { if (!b->next_) {

12
include/boost/unordered/detail/table.hpp
View File

@ -402,7 +402,7 @@ namespace boost { namespace unordered { namespace detail {
// Or from rehash post-condition: // Or from rehash post-condition:
// count > size / mlf_ // count > size / mlf_
return this->new_bucket_count( return policy::new_bucket_count(
boost::unordered::detail::double_to_size(floor( boost::unordered::detail::double_to_size(floor(
static_cast<double>(size) / static_cast<double>(size) /
static_cast<double>(mlf_))) + 1); static_cast<double>(mlf_))) + 1);
@ -415,7 +415,7 @@ namespace boost { namespace unordered { namespace detail {
hasher const& hf, hasher const& hf,
key_equal const& eq, key_equal const& eq,
node_allocator const& a) : node_allocator const& a) :
buckets(a, this->new_bucket_count(num_buckets)), buckets(a, policy::new_bucket_count(num_buckets)),
functions(hf, eq), functions(hf, eq),
mlf_(1.0f), mlf_(1.0f),
max_load_(0) max_load_(0)
@ -595,7 +595,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t hash(key_type const& k) const std::size_t hash(key_type const& k) const
{ {
return this->apply_hash(this->hash_function(), k); return policy::apply_hash(this->hash_function(), k);
} }
// Find Node // Find Node
@ -608,7 +608,7 @@ namespace boost { namespace unordered { namespace detail {
{ {
if (!this->size_) return node_pointer(); if (!this->size_) return node_pointer();
return static_cast<table_impl const*>(this)-> return static_cast<table_impl const*>(this)->
find_node_impl(this->apply_hash(hash_function, k), k, eq); find_node_impl(policy::apply_hash(hash_function, k), k, eq);
} }
node_pointer find_node( node_pointer find_node(
@ -678,10 +678,10 @@ namespace boost { namespace unordered { namespace detail {
if(!this->size_) { if(!this->size_) {
if(this->buckets_) this->delete_buckets(); if(this->buckets_) this->delete_buckets();
this->bucket_count_ = this->new_bucket_count(min_buckets); this->bucket_count_ = policy::new_bucket_count(min_buckets);
} }
else { else {
min_buckets = this->new_bucket_count((std::max)(min_buckets, min_buckets = policy::new_bucket_count((std::max)(min_buckets,
boost::unordered::detail::double_to_size(floor( boost::unordered::detail::double_to_size(floor(
static_cast<double>(this->size_) / static_cast<double>(this->size_) /
static_cast<double>(mlf_))) + 1)); static_cast<double>(mlf_))) + 1));

27
include/boost/unordered/detail/unique.hpp
View File

@ -169,6 +169,7 @@ namespace boost { namespace unordered { namespace detail {
typedef typename table::value_type value_type; typedef typename table::value_type value_type;
typedef typename table::bucket bucket; typedef typename table::bucket bucket;
typedef typename table::buckets buckets; typedef typename table::buckets buckets;
typedef typename table::policy policy;
typedef typename table::node_pointer node_pointer; typedef typename table::node_pointer node_pointer;
typedef typename table::node_allocator node_allocator; typedef typename table::node_allocator node_allocator;
typedef typename table::node_allocator_traits node_allocator_traits; typedef typename table::node_allocator_traits node_allocator_traits;
@ -221,7 +222,8 @@ namespace boost { namespace unordered { namespace detail {
Key const& k, Key const& k,
Pred const& eq) const Pred const& eq) const
{ {
std::size_t bucket_index = this->to_bucket(this->bucket_count_, hash); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, hash);
node_pointer n = this->get_start(bucket_index); node_pointer n = this->get_start(bucket_index);
for (;;) for (;;)
@ -236,7 +238,8 @@ namespace boost { namespace unordered { namespace detail {
} }
else else
{ {
if (this->to_bucket(this->bucket_count_, node_hash) != bucket_index) if (policy::to_bucket(this->bucket_count_, node_hash)
!= bucket_index)
return node_pointer(); return node_pointer();
} }
@ -302,14 +305,15 @@ namespace boost { namespace unordered { namespace detail {
node_pointer n = a.release(); node_pointer n = a.release();
n->hash_ = hash; n->hash_ = hash;
bucket_pointer b = this->get_bucket(this->to_bucket(this->bucket_count_, hash)); bucket_pointer b = this->get_bucket(
policy::to_bucket(this->bucket_count_, hash));
if (!b->next_) if (!b->next_)
{ {
previous_pointer start_node = this->get_previous_start(); previous_pointer start_node = this->get_previous_start();
if (start_node->next_) { if (start_node->next_) {
this->get_bucket(this->to_bucket(this->bucket_count_, this->get_bucket(policy::to_bucket(this->bucket_count_,
static_cast<node_pointer>(start_node->next_)->hash_) static_cast<node_pointer>(start_node->next_)->hash_)
)->next_ = n; )->next_ = n;
} }
@ -528,7 +532,8 @@ namespace boost { namespace unordered { namespace detail {
if(!this->size_) return 0; if(!this->size_) return 0;
std::size_t hash = this->hash(k); std::size_t hash = this->hash(k);
std::size_t bucket_index = this->to_bucket(this->bucket_count_, hash); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, hash);
bucket_pointer bucket = this->get_bucket(bucket_index); bucket_pointer bucket = this->get_bucket(bucket_index);
previous_pointer prev = bucket->next_; previous_pointer prev = bucket->next_;
@ -539,7 +544,8 @@ namespace boost { namespace unordered { namespace detail {
if (!prev->next_) return 0; if (!prev->next_) return 0;
std::size_t node_hash = std::size_t node_hash =
static_cast<node_pointer>(prev->next_)->hash_; static_cast<node_pointer>(prev->next_)->hash_;
if (this->to_bucket(this->bucket_count_, node_hash) != bucket_index) if (policy::to_bucket(this->bucket_count_, node_hash)
!= bucket_index)
return 0; return 0;
if (node_hash == hash && if (node_hash == hash &&
this->key_eq()(k, this->get_key( this->key_eq()(k, this->get_key(
@ -561,7 +567,7 @@ namespace boost { namespace unordered { namespace detail {
node_pointer next = static_cast<node_pointer>(r->next_); node_pointer next = static_cast<node_pointer>(r->next_);
bucket_pointer bucket = this->get_bucket( bucket_pointer bucket = this->get_bucket(
this->to_bucket(this->bucket_count_, r->hash_)); policy::to_bucket(this->bucket_count_, r->hash_));
previous_pointer prev = unlink_node(*bucket, r); previous_pointer prev = unlink_node(*bucket, r);
this->fix_buckets(bucket, prev, next); this->fix_buckets(bucket, prev, next);
@ -575,7 +581,8 @@ namespace boost { namespace unordered { namespace detail {
{ {
if (r1 == r2) return r2; if (r1 == r2) return r2;
std::size_t bucket_index = this->to_bucket(this->bucket_count_, r1->hash_); std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, r1->hash_);
previous_pointer prev = unlink_nodes( previous_pointer prev = unlink_nodes(
*this->get_bucket(bucket_index), r1, r2); *this->get_bucket(bucket_index), r1, r2);
this->fix_buckets_range(bucket_index, prev, r1, r2); this->fix_buckets_range(bucket_index, prev, r1, r2);
@ -693,8 +700,8 @@ namespace boost { namespace unordered { namespace detail {
previous_pointer prev) previous_pointer prev)
{ {
node_pointer n = static_cast<node_pointer>(prev->next_); node_pointer n = static_cast<node_pointer>(prev->next_);
bucket_pointer b = dst.get_bucket(dst.to_bucket(dst.bucket_count_, bucket_pointer b = dst.get_bucket(
n->hash_)); buckets::to_bucket(dst.bucket_count_, n->hash_));
if (!b->next_) { if (!b->next_) {
b->next_ = prev; b->next_ = prev;

4
include/boost/unordered/unordered_map.hpp
View File

@ -465,7 +465,7 @@ namespace unordered
size_type bucket(const key_type& k) const size_type bucket(const key_type& k) const
{ {
return table_.to_bucket(table_.bucket_count_, return table::to_bucket(table_.bucket_count_,
table_.hash(k)); table_.hash(k));
} }
@ -947,7 +947,7 @@ namespace unordered
size_type bucket(const key_type& k) const size_type bucket(const key_type& k) const
{ {
return table_.to_bucket(table_.bucket_count_, return table::to_bucket(table_.bucket_count_,
table_.hash(k)); table_.hash(k));
} }

4
include/boost/unordered/unordered_set.hpp
View File

@ -450,7 +450,7 @@ namespace unordered
size_type bucket(const key_type& k) const size_type bucket(const key_type& k) const
{ {
return table_.to_bucket(table_.bucket_count_, return table::to_bucket(table_.bucket_count_,
table_.hash(k)); table_.hash(k));
} }
@ -922,7 +922,7 @@ namespace unordered
size_type bucket(const key_type& k) const size_type bucket(const key_type& k) const
{ {
return table_.to_bucket(table_.bucket_count_, return table::to_bucket(table_.bucket_count_,
table_.hash(k)); table_.hash(k));
} }