boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 03:17:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Unordered: Simplify pointer use.

Browse Source 
[SVN r81206]
This commit is contained in:
Daniel James
2012-11-05 18:32:45 +00:00
parent 2e26534659
commit 38d8d052d1
4 changed files with 61 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -445,7 +445,7 @@ namespace boost { namespace unordered { namespace detail {
nodes_() nodes_()
{ {
if (b.size_) { if (b.size_) {
typename Table::previous_pointer prev = b.get_previous_start(); typename Table::link_pointer prev = b.get_previous_start();
nodes_ = static_cast<node_pointer>(prev->next_); nodes_ = static_cast<node_pointer>(prev->next_);
prev->next_ = link_pointer(); prev->next_ = link_pointer();
b.size_ = 0; b.size_ = 0;
@ -537,12 +537,12 @@ namespace boost { namespace unordered { namespace detail {
template <typename NodePointer> template <typename NodePointer>
struct bucket struct bucket
{ {
typedef NodePointer previous_pointer; typedef NodePointer link_pointer;
previous_pointer next_; link_pointer next_;
bucket() : next_() {} bucket() : next_() {}
previous_pointer first_from_start() link_pointer first_from_start()
{ {
return next_; return next_;
} }
@ -552,12 +552,12 @@ namespace boost { namespace unordered { namespace detail {
struct ptr_bucket struct ptr_bucket
{ {
typedef ptr_bucket* previous_pointer; typedef ptr_bucket* link_pointer;
previous_pointer next_; link_pointer next_;
ptr_bucket() : next_(0) {} ptr_bucket() : next_(0) {}
previous_pointer first_from_start() link_pointer first_from_start()
{ {
return this; return this;
} }

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

@ -181,7 +181,6 @@ namespace boost { namespace unordered { namespace detail {
typedef typename table::node_allocator_traits node_allocator_traits; typedef typename table::node_allocator_traits node_allocator_traits;
typedef typename table::bucket_pointer bucket_pointer; typedef typename table::bucket_pointer bucket_pointer;
typedef typename table::link_pointer link_pointer; typedef typename table::link_pointer link_pointer;
typedef typename table::previous_pointer previous_pointer;
typedef typename table::hasher hasher; typedef typename table::hasher hasher;
typedef typename table::key_equal key_equal; typedef typename table::key_equal key_equal;
typedef typename table::key_type key_type; typedef typename table::key_type key_type;
@ -397,9 +396,8 @@ namespace boost { namespace unordered { namespace detail {
{ {
n->next_ = static_cast<node_pointer>(pos->group_prev_)->next_; n->next_ = static_cast<node_pointer>(pos->group_prev_)->next_;
n->group_prev_ = pos->group_prev_; n->group_prev_ = pos->group_prev_;
static_cast<node_pointer>(pos->group_prev_)->next_ = static_cast<node_pointer>(pos->group_prev_)->next_ = n;
static_cast<link_pointer>(n); pos->group_prev_ = n;
pos->group_prev_ = static_cast<link_pointer>(n);
} }
inline iterator add_node( inline iterator add_node(
@ -427,7 +425,7 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_) if (!b->next_)
{ {
previous_pointer start_node = this->get_previous_start(); link_pointer start_node = this->get_previous_start();
if (start_node->next_) { if (start_node->next_) {
this->get_bucket(policy::to_bucket(this->bucket_count_, this->get_bucket(policy::to_bucket(this->bucket_count_,
@ -437,12 +435,12 @@ namespace boost { namespace unordered { namespace detail {
b->next_ = start_node; b->next_ = start_node;
n->next_ = start_node->next_; n->next_ = start_node->next_;
start_node->next_ = static_cast<link_pointer>(n); start_node->next_ = n;
} }
else else
{ {
n->next_ = b->next_->next_; n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n); b->next_->next_ = n;
} }
} }
++this->size_; ++this->size_;
@ -549,7 +547,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(this->bucket_count_, key_hash); policy::to_bucket(this->bucket_count_, key_hash);
bucket_pointer this_bucket = this->get_bucket(bucket_index); bucket_pointer this_bucket = this->get_bucket(bucket_index);
previous_pointer prev = this_bucket->next_; link_pointer prev = this_bucket->next_;
if (!prev) return 0; if (!prev) return 0;
for (;;) for (;;)
@ -564,8 +562,7 @@ namespace boost { namespace unordered { namespace detail {
this->key_eq()(k, this->get_key( this->key_eq()(k, this->get_key(
static_cast<node_pointer>(prev->next_)->value()))) static_cast<node_pointer>(prev->next_)->value())))
break; break;
prev = static_cast<previous_pointer>( prev = static_cast<node_pointer>(prev->next_)->group_prev_;
static_cast<node_pointer>(prev->next_)->group_prev_);
} }
node_pointer pos = static_cast<node_pointer>(prev->next_); node_pointer pos = static_cast<node_pointer>(prev->next_);
@ -585,7 +582,7 @@ namespace boost { namespace unordered { namespace detail {
bucket_pointer this_bucket = this->get_bucket( bucket_pointer this_bucket = this->get_bucket(
policy::to_bucket(this->bucket_count_, r.node_->hash_)); policy::to_bucket(this->bucket_count_, r.node_->hash_));
previous_pointer prev = unlink_node(*this_bucket, r.node_); link_pointer prev = unlink_node(*this_bucket, r.node_);
this->fix_buckets(this_bucket, prev, next.node_); this->fix_buckets(this_bucket, prev, next.node_);
@ -600,7 +597,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t bucket_index = std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, r1.node_->hash_); policy::to_bucket(this->bucket_count_, r1.node_->hash_);
previous_pointer prev = unlink_nodes( link_pointer prev = unlink_nodes(
*this->get_bucket(bucket_index), r1.node_, r2.node_); *this->get_bucket(bucket_index), r1.node_, r2.node_);
this->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_); this->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_);
this->delete_nodes(r1, r2); this->delete_nodes(r1, r2);
@ -608,11 +605,10 @@ namespace boost { namespace unordered { namespace detail {
return iterator(r2.node_); return iterator(r2.node_);
} }
static previous_pointer unlink_node(bucket& b, node_pointer n) static link_pointer unlink_node(bucket& b, node_pointer n)
{ {
node_pointer next = static_cast<node_pointer>(n->next_); node_pointer next = static_cast<node_pointer>(n->next_);
previous_pointer prev = link_pointer prev = n->group_prev_;
static_cast<previous_pointer>(n->group_prev_);
if(prev->next_ != n) { if(prev->next_ != n) {
// The node is at the beginning of a group. // The node is at the beginning of a group.
@ -620,17 +616,16 @@ namespace boost { namespace unordered { namespace detail {
// Find the previous node pointer: // Find the previous node pointer:
prev = b.next_; prev = b.next_;
while(prev->next_ != n) { while(prev->next_ != n) {
prev = static_cast<previous_pointer>( prev = static_cast<node_pointer>(prev->next_)->group_prev_;
static_cast<node_pointer>(prev->next_)->group_prev_);
} }
// Remove from group // Remove from group
if (next && next->group_prev_ == static_cast<link_pointer>(n)) if (next && next->group_prev_ == n)
{ {
next->group_prev_ = n->group_prev_; next->group_prev_ = n->group_prev_;
} }
} }
else if (next && next->group_prev_ == static_cast<link_pointer>(n)) else if (next && next->group_prev_ == n)
{ {
// The deleted node is not at the end of the group, so // The deleted node is not at the end of the group, so
// change the link from the next node. // change the link from the next node.
@ -641,30 +636,28 @@ namespace boost { namespace unordered { namespace detail {
// first node in the group is pointing to it. // first node in the group is pointing to it.
// Find that to change its pointer. // Find that to change its pointer.
node_pointer x = static_cast<node_pointer>(n->group_prev_); node_pointer x = static_cast<node_pointer>(n->group_prev_);
while(x->group_prev_ != static_cast<link_pointer>(n)) { while (x->group_prev_ != n) {
x = static_cast<node_pointer>(x->group_prev_); x = static_cast<node_pointer>(x->group_prev_);
} }
x->group_prev_ = n->group_prev_; x->group_prev_ = n->group_prev_;
} }
prev->next_ = static_cast<link_pointer>(next); prev->next_ = next;
return prev; return prev;
} }
static previous_pointer unlink_nodes(bucket& b, static link_pointer unlink_nodes(bucket& b,
node_pointer begin, node_pointer end) node_pointer begin, node_pointer end)
{ {
previous_pointer prev = static_cast<previous_pointer>( link_pointer prev = begin->group_prev_;
begin->group_prev_);
if(prev->next_ != static_cast<link_pointer>(begin)) { if (prev->next_ != begin) {
// The node is at the beginning of a group. // The node is at the beginning of a group.
// Find the previous node pointer: // Find the previous node pointer:
prev = b.next_; prev = b.next_;
while(prev->next_ != static_cast<link_pointer>(begin)) while (prev->next_ != begin)
prev = static_cast<previous_pointer>( prev = static_cast<node_pointer>(prev->next_)->group_prev_;
static_cast<node_pointer>(prev->next_)->group_prev_);
if (end) split_group(end); if (end) split_group(end);
} }
@ -683,7 +676,7 @@ namespace boost { namespace unordered { namespace detail {
} }
} }
prev->next_ = static_cast<link_pointer>(end); prev->next_ = end;
return prev; return prev;
} }
@ -696,7 +689,7 @@ namespace boost { namespace unordered { namespace detail {
// Find first node in group. // Find first node in group.
node_pointer first = split; node_pointer first = split;
while (static_cast<node_pointer>(first->group_prev_)->next_ == while (static_cast<node_pointer>(first->group_prev_)->next_ ==
static_cast<link_pointer>(first)) first)
first = static_cast<node_pointer>(first->group_prev_); first = static_cast<node_pointer>(first->group_prev_);
if(first == split) return split; if(first == split) return split;
@ -715,7 +708,7 @@ namespace boost { namespace unordered { namespace detail {
static void fill_buckets(iterator n, table& dst, static void fill_buckets(iterator n, table& dst,
NodeCreator& creator) NodeCreator& creator)
{ {
previous_pointer prev = dst.get_previous_start(); link_pointer prev = dst.get_previous_start();
while (n.node_) { while (n.node_) {
std::size_t key_hash = n.node_->hash_; std::size_t key_hash = n.node_->hash_;
@ -727,7 +720,7 @@ namespace boost { namespace unordered { namespace detail {
node_pointer first_node = creator.create(*n); node_pointer first_node = creator.create(*n);
node_pointer end = first_node; node_pointer end = first_node;
first_node->hash_ = key_hash; first_node->hash_ = key_hash;
prev->next_ = static_cast<link_pointer>(first_node); prev->next_ = first_node;
++dst.size_; ++dst.size_;
for (++n; n != group_end; ++n) for (++n; n != group_end; ++n)
@ -748,7 +741,7 @@ namespace boost { namespace unordered { namespace detail {
BOOST_ASSERT(this->buckets_); BOOST_ASSERT(this->buckets_);
this->create_buckets(num_buckets); this->create_buckets(num_buckets);
previous_pointer prev = this->get_previous_start(); link_pointer prev = this->get_previous_start();
while (prev->next_) while (prev->next_)
prev = place_in_bucket(*this, prev, prev = place_in_bucket(*this, prev,
static_cast<node_pointer>( static_cast<node_pointer>(
@ -757,15 +750,15 @@ namespace boost { namespace unordered { namespace detail {
// Iterate through the nodes placing them in the correct buckets. // Iterate through the nodes placing them in the correct buckets.
// pre: prev->next_ is not null. // pre: prev->next_ is not null.
static previous_pointer place_in_bucket(table& dst, static link_pointer place_in_bucket(table& dst,
previous_pointer prev, node_pointer end) link_pointer prev, node_pointer end)
{ {
bucket_pointer b = dst.get_bucket(policy::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_) {
b->next_ = static_cast<node_pointer>(prev); b->next_ = static_cast<node_pointer>(prev);
return static_cast<previous_pointer>(end); return end;
} }
else { else {
link_pointer next = end->next_; link_pointer next = end->next_;

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

@ -164,8 +164,6 @@ namespace boost { namespace unordered { namespace detail {
const_node_pointer; const_node_pointer;
typedef typename bucket_allocator_traits::pointer typedef typename bucket_allocator_traits::pointer
bucket_pointer; bucket_pointer;
typedef typename bucket::previous_pointer
previous_pointer;
typedef boost::unordered::detail::node_constructor<node_allocator> typedef boost::unordered::detail::node_constructor<node_allocator>
node_constructor; node_constructor;
@ -226,12 +224,12 @@ namespace boost { namespace unordered { namespace detail {
return buckets_ + static_cast<std::ptrdiff_t>(bucket_index); return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
} }
previous_pointer get_previous_start() const link_pointer get_previous_start() const
{ {
return get_bucket(bucket_count_)->first_from_start(); return get_bucket(bucket_count_)->first_from_start();
} }
previous_pointer get_previous_start(std::size_t bucket_index) const link_pointer get_previous_start(std::size_t bucket_index) const
{ {
return get_bucket(bucket_index)->next_; return get_bucket(bucket_index)->next_;
} }
@ -245,7 +243,7 @@ namespace boost { namespace unordered { namespace detail {
iterator begin(std::size_t bucket_index) const iterator begin(std::size_t bucket_index) const
{ {
if (!size_) return iterator(); if (!size_) return iterator();
previous_pointer prev = get_previous_start(bucket_index); link_pointer prev = get_previous_start(bucket_index);
return prev ? iterator(static_cast<node_pointer>(prev->next_)) : return prev ? iterator(static_cast<node_pointer>(prev->next_)) :
iterator(); iterator();
} }
@ -584,7 +582,7 @@ namespace boost { namespace unordered { namespace detail {
// This is called after erasing a node or group of nodes to fix up // This is called after erasing a node or group of nodes to fix up
// the bucket pointers. // the bucket pointers.
void fix_buckets(bucket_pointer this_bucket, void fix_buckets(bucket_pointer this_bucket,
previous_pointer prev, node_pointer next) link_pointer prev, node_pointer next)
{ {
if (!next) if (!next)
{ {
@ -608,7 +606,7 @@ namespace boost { namespace unordered { namespace detail {
// This is called after erasing a range of nodes to fix any bucket // This is called after erasing a range of nodes to fix any bucket
// pointers into that range. // pointers into that range.
void fix_buckets_range(std::size_t bucket_index, void fix_buckets_range(std::size_t bucket_index,
previous_pointer prev, node_pointer begin, node_pointer end) link_pointer prev, node_pointer begin, node_pointer end)
{ {
node_pointer n = begin; node_pointer n = begin;
@ -640,7 +638,7 @@ namespace boost { namespace unordered { namespace detail {
// Iterate through the remaining nodes, clearing out the bucket // Iterate through the remaining nodes, clearing out the bucket
// pointers. // pointers.
get_bucket(bucket_index)->next_ = previous_pointer(); get_bucket(bucket_index)->next_ = link_pointer();
for(;;) { for(;;) {
n = static_cast<node_pointer>(n->next_); n = static_cast<node_pointer>(n->next_);
if (n == end) break; if (n == end) break;
@ -649,7 +647,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(bucket_count_, n->hash_); policy::to_bucket(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;
get_bucket(bucket_index)->next_ = previous_pointer(); get_bucket(bucket_index)->next_ = link_pointer();
} }
}; };

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

@ -176,7 +176,6 @@ namespace boost { namespace unordered { namespace detail {
typedef typename table::node_allocator_traits node_allocator_traits; typedef typename table::node_allocator_traits node_allocator_traits;
typedef typename table::bucket_pointer bucket_pointer; typedef typename table::bucket_pointer bucket_pointer;
typedef typename table::link_pointer link_pointer; typedef typename table::link_pointer link_pointer;
typedef typename table::previous_pointer previous_pointer;
typedef typename table::hasher hasher; typedef typename table::hasher hasher;
typedef typename table::key_equal key_equal; typedef typename table::key_equal key_equal;
typedef typename table::key_type key_type; typedef typename table::key_type key_type;
@ -317,7 +316,7 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_) if (!b->next_)
{ {
previous_pointer start_node = this->get_previous_start(); link_pointer start_node = this->get_previous_start();
if (start_node->next_) { if (start_node->next_) {
this->get_bucket(policy::to_bucket(this->bucket_count_, this->get_bucket(policy::to_bucket(this->bucket_count_,
@ -327,12 +326,12 @@ namespace boost { namespace unordered { namespace detail {
b->next_ = start_node; b->next_ = start_node;
n->next_ = start_node->next_; n->next_ = start_node->next_;
start_node->next_ = static_cast<link_pointer>(n); start_node->next_ = n;
} }
else else
{ {
n->next_ = b->next_->next_; n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n); b->next_->next_ = n;
} }
++this->size_; ++this->size_;
@ -522,7 +521,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(this->bucket_count_, key_hash); policy::to_bucket(this->bucket_count_, key_hash);
bucket_pointer this_bucket = this->get_bucket(bucket_index); bucket_pointer this_bucket = this->get_bucket(bucket_index);
previous_pointer prev = this_bucket->next_; link_pointer prev = this_bucket->next_;
if (!prev) return 0; if (!prev) return 0;
for (;;) for (;;)
@ -537,7 +536,7 @@ namespace boost { namespace unordered { namespace detail {
this->key_eq()(k, this->get_key( this->key_eq()(k, this->get_key(
static_cast<node_pointer>(prev->next_)->value()))) static_cast<node_pointer>(prev->next_)->value())))
break; break;
prev = static_cast<previous_pointer>(prev->next_); prev = prev->next_;
} }
node_pointer pos = static_cast<node_pointer>(prev->next_); node_pointer pos = static_cast<node_pointer>(prev->next_);
@ -555,7 +554,7 @@ namespace boost { namespace unordered { namespace detail {
bucket_pointer this_bucket = this->get_bucket( bucket_pointer this_bucket = this->get_bucket(
policy::to_bucket(this->bucket_count_, r.node_->hash_)); policy::to_bucket(this->bucket_count_, r.node_->hash_));
previous_pointer prev = unlink_node(*this_bucket, r.node_); link_pointer prev = unlink_node(*this_bucket, r.node_);
this->fix_buckets(this_bucket, prev, next.node_); this->fix_buckets(this_bucket, prev, next.node_);
@ -570,7 +569,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t bucket_index = std::size_t bucket_index =
policy::to_bucket(this->bucket_count_, r1.node_->hash_); policy::to_bucket(this->bucket_count_, r1.node_->hash_);
previous_pointer prev = unlink_nodes( link_pointer prev = unlink_nodes(
*this->get_bucket(bucket_index), r1.node_, r2.node_); *this->get_bucket(bucket_index), r1.node_, r2.node_);
this->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_); this->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_);
this->delete_nodes(r1, r2); this->delete_nodes(r1, r2);
@ -578,19 +577,17 @@ namespace boost { namespace unordered { namespace detail {
return iterator(r2.node_); return iterator(r2.node_);
} }
static previous_pointer unlink_node(bucket& b, node_pointer n) static link_pointer unlink_node(bucket& b, node_pointer n)
{ {
return unlink_nodes(b, n, static_cast<node_pointer>(n->next_)); return unlink_nodes(b, n, static_cast<node_pointer>(n->next_));
} }
static previous_pointer unlink_nodes(bucket& b, static link_pointer unlink_nodes(bucket& b,
node_pointer begin, node_pointer end) node_pointer begin, node_pointer end)
{ {
previous_pointer prev = b.next_; link_pointer prev = b.next_;
link_pointer begin_void = static_cast<link_pointer>(begin); while (prev->next_ != begin) prev = prev->next_;
while(prev->next_ != begin_void) prev->next_ = end;
prev = static_cast<previous_pointer>(prev->next_);
prev->next_ = static_cast<link_pointer>(end);
return prev; return prev;
} }
@ -601,12 +598,12 @@ namespace boost { namespace unordered { namespace detail {
static void fill_buckets(iterator n, table& dst, static void fill_buckets(iterator n, table& dst,
NodeCreator& creator) NodeCreator& creator)
{ {
previous_pointer prev = dst.get_previous_start(); link_pointer prev = dst.get_previous_start();
while (n.node_) { while (n.node_) {
node_pointer node = creator.create(*n); node_pointer node = creator.create(*n);
node->hash_ = n.node_->hash_; node->hash_ = n.node_->hash_;
prev->next_ = static_cast<link_pointer>(node); prev->next_ = node;
++dst.size_; ++dst.size_;
++n; ++n;
@ -620,15 +617,14 @@ namespace boost { namespace unordered { namespace detail {
BOOST_ASSERT(this->buckets_); BOOST_ASSERT(this->buckets_);
this->create_buckets(num_buckets); this->create_buckets(num_buckets);
previous_pointer prev = this->get_previous_start(); link_pointer prev = this->get_previous_start();
while (prev->next_) while (prev->next_)
prev = place_in_bucket(*this, prev); prev = place_in_bucket(*this, prev);
} }
// Iterate through the nodes placing them in the correct buckets. // Iterate through the nodes placing them in the correct buckets.
// pre: prev->next_ is not null. // pre: prev->next_ is not null.
static previous_pointer place_in_bucket(table& dst, static link_pointer place_in_bucket(table& dst, link_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( bucket_pointer b = dst.get_bucket(
@ -636,12 +632,12 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_) { if (!b->next_) {
b->next_ = prev; b->next_ = prev;
return static_cast<previous_pointer>(n); return n;
} }
else { else {
prev->next_ = n->next_; prev->next_ = n->next_;
n->next_ = b->next_->next_; n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n); b->next_->next_ = n;
return prev; return prev;
} }
} }