boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-29 19:07: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_()
{
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_);
prev->next_ = link_pointer();
b.size_ = 0;
@ -537,12 +537,12 @@ namespace boost { namespace unordered { namespace detail {
template <typename NodePointer>
struct bucket
{
typedef NodePointer previous_pointer;
previous_pointer next_;
typedef NodePointer link_pointer;
link_pointer next_;
bucket() : next_() {}
previous_pointer first_from_start()
link_pointer first_from_start()
{
return next_;
}
@ -552,12 +552,12 @@ namespace boost { namespace unordered { namespace detail {
struct ptr_bucket
{
typedef ptr_bucket* previous_pointer;
previous_pointer next_;
typedef ptr_bucket* link_pointer;
link_pointer next_;
ptr_bucket() : next_(0) {}
previous_pointer first_from_start()
link_pointer first_from_start()
{
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::bucket_pointer bucket_pointer;
typedef typename table::link_pointer link_pointer;
typedef typename table::previous_pointer previous_pointer;
typedef typename table::hasher hasher;
typedef typename table::key_equal key_equal;
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->group_prev_ = pos->group_prev_;
static_cast<node_pointer>(pos->group_prev_)->next_ =
static_cast<link_pointer>(n);
pos->group_prev_ = static_cast<link_pointer>(n);
static_cast<node_pointer>(pos->group_prev_)->next_ = n;
pos->group_prev_ = n;
}
inline iterator add_node(
@ -427,7 +425,7 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_)
{
previous_pointer start_node = this->get_previous_start();
link_pointer start_node = this->get_previous_start();
if (start_node->next_) {
this->get_bucket(policy::to_bucket(this->bucket_count_,
@ -437,12 +435,12 @@ namespace boost { namespace unordered { namespace detail {
b->next_ = start_node;
n->next_ = start_node->next_;
start_node->next_ = static_cast<link_pointer>(n);
start_node->next_ = n;
}
else
{
n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n);
b->next_->next_ = n;
}
}
++this->size_;
@ -549,7 +547,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(this->bucket_count_, key_hash);
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;
for (;;)
@ -564,8 +562,7 @@ namespace boost { namespace unordered { namespace detail {
this->key_eq()(k, this->get_key(
static_cast<node_pointer>(prev->next_)->value())))
break;
prev = static_cast<previous_pointer>(
static_cast<node_pointer>(prev->next_)->group_prev_);
prev = static_cast<node_pointer>(prev->next_)->group_prev_;
}
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(
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_);
@ -600,7 +597,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t bucket_index =
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->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_);
this->delete_nodes(r1, r2);
@ -608,11 +605,10 @@ namespace boost { namespace unordered { namespace detail {
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_);
previous_pointer prev =
static_cast<previous_pointer>(n->group_prev_);
link_pointer prev = n->group_prev_;
if(prev->next_ != n) {
// The node is at the beginning of a group.
@ -620,17 +616,16 @@ namespace boost { namespace unordered { namespace detail {
// Find the previous node pointer:
prev = b.next_;
while(prev->next_ != n) {
prev = static_cast<previous_pointer>(
static_cast<node_pointer>(prev->next_)->group_prev_);
prev = static_cast<node_pointer>(prev->next_)->group_prev_;
}
// 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_;
}
}
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
// 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.
// Find that to change its pointer.
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->group_prev_ = n->group_prev_;
}
prev->next_ = static_cast<link_pointer>(next);
prev->next_ = next;
return prev;
}
static previous_pointer unlink_nodes(bucket& b,
static link_pointer unlink_nodes(bucket& b,
node_pointer begin, node_pointer end)
{
previous_pointer prev = static_cast<previous_pointer>(
begin->group_prev_);
link_pointer 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.
// Find the previous node pointer:
prev = b.next_;
while(prev->next_ != static_cast<link_pointer>(begin))
prev = static_cast<previous_pointer>(
static_cast<node_pointer>(prev->next_)->group_prev_);
while (prev->next_ != begin)
prev = static_cast<node_pointer>(prev->next_)->group_prev_;
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;
}
@ -696,7 +689,7 @@ namespace boost { namespace unordered { namespace detail {
// Find first node in group.
node_pointer first = split;
while (static_cast<node_pointer>(first->group_prev_)->next_ ==
static_cast<link_pointer>(first))
first)
first = static_cast<node_pointer>(first->group_prev_);
if(first == split) return split;
@ -715,7 +708,7 @@ namespace boost { namespace unordered { namespace detail {
static void fill_buckets(iterator n, table& dst,
NodeCreator& creator)
{
previous_pointer prev = dst.get_previous_start();
link_pointer prev = dst.get_previous_start();
while (n.node_) {
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 end = first_node;
first_node->hash_ = key_hash;
prev->next_ = static_cast<link_pointer>(first_node);
prev->next_ = first_node;
++dst.size_;
for (++n; n != group_end; ++n)
@ -748,7 +741,7 @@ namespace boost { namespace unordered { namespace detail {
BOOST_ASSERT(this->buckets_);
this->create_buckets(num_buckets);
previous_pointer prev = this->get_previous_start();
link_pointer prev = this->get_previous_start();
while (prev->next_)
prev = place_in_bucket(*this, prev,
static_cast<node_pointer>(
@ -757,15 +750,15 @@ namespace boost { namespace unordered { namespace detail {
// Iterate through the nodes placing them in the correct buckets.
// pre: prev->next_ is not null.
static previous_pointer place_in_bucket(table& dst,
previous_pointer prev, node_pointer end)
static link_pointer place_in_bucket(table& dst,
link_pointer prev, node_pointer end)
{
bucket_pointer b = dst.get_bucket(policy::to_bucket(
dst.bucket_count_, end->hash_));
if (!b->next_) {
b->next_ = static_cast<node_pointer>(prev);
return static_cast<previous_pointer>(end);
return end;
}
else {
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;
typedef typename bucket_allocator_traits::pointer
bucket_pointer;
typedef typename bucket::previous_pointer
previous_pointer;
typedef boost::unordered::detail::node_constructor<node_allocator>
node_constructor;
@ -226,12 +224,12 @@ namespace boost { namespace unordered { namespace detail {
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();
}
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_;
}
@ -245,7 +243,7 @@ namespace boost { namespace unordered { namespace detail {
iterator begin(std::size_t bucket_index) const
{
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_)) :
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
// the bucket pointers.
void fix_buckets(bucket_pointer this_bucket,
previous_pointer prev, node_pointer next)
link_pointer prev, node_pointer 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
// pointers into that range.
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;
@ -640,7 +638,7 @@ namespace boost { namespace unordered { namespace detail {
// Iterate through the remaining nodes, clearing out the bucket
// pointers.
get_bucket(bucket_index)->next_ = previous_pointer();
get_bucket(bucket_index)->next_ = link_pointer();
for(;;) {
n = static_cast<node_pointer>(n->next_);
if (n == end) break;
@ -649,7 +647,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(bucket_count_, n->hash_);
if (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::bucket_pointer bucket_pointer;
typedef typename table::link_pointer link_pointer;
typedef typename table::previous_pointer previous_pointer;
typedef typename table::hasher hasher;
typedef typename table::key_equal key_equal;
typedef typename table::key_type key_type;
@ -317,7 +316,7 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_)
{
previous_pointer start_node = this->get_previous_start();
link_pointer start_node = this->get_previous_start();
if (start_node->next_) {
this->get_bucket(policy::to_bucket(this->bucket_count_,
@ -327,12 +326,12 @@ namespace boost { namespace unordered { namespace detail {
b->next_ = start_node;
n->next_ = start_node->next_;
start_node->next_ = static_cast<link_pointer>(n);
start_node->next_ = n;
}
else
{
n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n);
b->next_->next_ = n;
}
++this->size_;
@ -522,7 +521,7 @@ namespace boost { namespace unordered { namespace detail {
policy::to_bucket(this->bucket_count_, key_hash);
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;
for (;;)
@ -537,7 +536,7 @@ namespace boost { namespace unordered { namespace detail {
this->key_eq()(k, this->get_key(
static_cast<node_pointer>(prev->next_)->value())))
break;
prev = static_cast<previous_pointer>(prev->next_);
prev = 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(
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_);
@ -570,7 +569,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t bucket_index =
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->fix_buckets_range(bucket_index, prev, r1.node_, r2.node_);
this->delete_nodes(r1, r2);
@ -578,19 +577,17 @@ namespace boost { namespace unordered { namespace detail {
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_));
}
static previous_pointer unlink_nodes(bucket& b,
static link_pointer unlink_nodes(bucket& b,
node_pointer begin, node_pointer end)
{
previous_pointer prev = b.next_;
link_pointer begin_void = static_cast<link_pointer>(begin);
while(prev->next_ != begin_void)
prev = static_cast<previous_pointer>(prev->next_);
prev->next_ = static_cast<link_pointer>(end);
link_pointer prev = b.next_;
while (prev->next_ != begin) prev = prev->next_;
prev->next_ = end;
return prev;
}
@ -601,12 +598,12 @@ namespace boost { namespace unordered { namespace detail {
static void fill_buckets(iterator n, table& dst,
NodeCreator& creator)
{
previous_pointer prev = dst.get_previous_start();
link_pointer prev = dst.get_previous_start();
while (n.node_) {
node_pointer node = creator.create(*n);
node->hash_ = n.node_->hash_;
prev->next_ = static_cast<link_pointer>(node);
prev->next_ = node;
++dst.size_;
++n;
@ -620,15 +617,14 @@ namespace boost { namespace unordered { namespace detail {
BOOST_ASSERT(this->buckets_);
this->create_buckets(num_buckets);
previous_pointer prev = this->get_previous_start();
link_pointer prev = this->get_previous_start();
while (prev->next_)
prev = place_in_bucket(*this, prev);
}
// Iterate through the nodes placing them in the correct buckets.
// pre: prev->next_ is not null.
static previous_pointer place_in_bucket(table& dst,
previous_pointer prev)
static link_pointer place_in_bucket(table& dst, link_pointer prev)
{
node_pointer n = static_cast<node_pointer>(prev->next_);
bucket_pointer b = dst.get_bucket(
@ -636,12 +632,12 @@ namespace boost { namespace unordered { namespace detail {
if (!b->next_) {
b->next_ = prev;
return static_cast<previous_pointer>(n);
return n;
}
else {
prev->next_ = n->next_;
n->next_ = b->next_->next_;
b->next_->next_ = static_cast<link_pointer>(n);
b->next_->next_ = n;
return prev;
}
}