Unordered: Merge code clean up.

[SVN r81358]
This commit is contained in:
Daniel James committed 2012-11-15 13:43:37 +00:00
1 parent 81897a6469
commit 981f1e2acb
7 files changed
+266 -418

No files matched your search

+50 -103
View File
@@ -125,7 +125,6 @@ namespace boost { namespace unordered { namespace detail {
template <typename Types>
struct table :
Types::policy,
boost::unordered::detail::functions<
typename Types::hasher,
typename Types::key_equal>
@@ -164,20 +163,17 @@ 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;
typedef boost::unordered::iterator_detail::
iterator<node_pointer, value_type> iterator;
iterator<node> iterator;
typedef boost::unordered::iterator_detail::
c_iterator<const_node_pointer, node_pointer, value_type> c_iterator;
c_iterator<node, const_node_pointer> c_iterator;
typedef boost::unordered::iterator_detail::
l_iterator<node_pointer, value_type, policy> l_iterator;
l_iterator<node, policy> l_iterator;
typedef boost::unordered::iterator_detail::
cl_iterator<const_node_pointer, node_pointer, value_type, policy>
cl_iterator;
cl_iterator<node, const_node_pointer, policy> cl_iterator;
////////////////////////////////////////////////////////////////////////
// Members
@@ -226,28 +222,31 @@ 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_;
}
iterator begin() const
{
return size_ ? iterator(static_cast<node_pointer>(
get_previous_start()->next_)) : iterator();
return size_ ? iterator(get_previous_start()->next_) : iterator();
}
iterator begin(std::size_t bucket_index) const
{
if (!size_) return iterator();
previous_pointer prev = get_previous_start(bucket_index);
return prev ? iterator(static_cast<node_pointer>(prev->next_)) :
iterator();
link_pointer prev = get_previous_start(bucket_index);
return prev ? iterator(prev->next_) : iterator();
}
std::size_t hash_to_bucket(std::size_t hash) const
{
return policy::to_bucket(bucket_count_, hash);
}
float load_factor() const
@@ -263,8 +262,7 @@ namespace boost { namespace unordered { namespace detail {
if (!it.node_) return 0;
std::size_t count = 0;
while(it.node_ && policy::to_bucket(
bucket_count_, it.node_->hash_) == index)
while(it.node_ && hash_to_bucket(it.node_->hash_) == index)
{
++count;
++it;
@@ -500,26 +498,29 @@ namespace boost { namespace unordered { namespace detail {
delete_buckets();
}
void delete_node(c_iterator n)
void delete_node(link_pointer prev)
{
node_pointer n = static_cast<node_pointer>(prev->next_);
prev->next_ = n->next_;
boost::unordered::detail::destroy_value_impl(node_alloc(),
n.node_->value_ptr());
n->value_ptr());
node_allocator_traits::destroy(node_alloc(),
boost::addressof(*n.node_));
node_allocator_traits::deallocate(node_alloc(), n.node_, 1);
boost::addressof(*n));
node_allocator_traits::deallocate(node_alloc(), n, 1);
--size_;
}
std::size_t delete_nodes(c_iterator begin, c_iterator end)
std::size_t delete_nodes(link_pointer prev, link_pointer end)
{
BOOST_ASSERT(prev->next_ != end);
std::size_t count = 0;
while(begin != end) {
c_iterator n = begin;
++begin;
delete_node(n);
do {
delete_node(prev);
++count;
}
} while (prev->next_ != end);
return count;
}
@@ -527,7 +528,7 @@ namespace boost { namespace unordered { namespace detail {
void delete_buckets()
{
if(buckets_) {
delete_nodes(begin(), iterator());
if (size_) delete_nodes(get_previous_start(), link_pointer());
if (bucket::extra_node) {
node_pointer n = static_cast<node_pointer>(
@@ -547,10 +548,9 @@ namespace boost { namespace unordered { namespace detail {
void clear()
{
if(!size_) return;
if (!size_) return;
delete_nodes(begin(), iterator());
get_previous_start()->next_ = link_pointer();
delete_nodes(get_previous_start(), link_pointer());
clear_buckets();
BOOST_ASSERT(!size_);
@@ -579,86 +579,33 @@ namespace boost { namespace unordered { namespace detail {
}
////////////////////////////////////////////////////////////////////////
// Fix buckets after erase
// Fix buckets after delete
//
// 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)
std::size_t fix_bucket(std::size_t bucket_index, link_pointer prev)
{
if (!next)
link_pointer end = prev->next_;
std::size_t bucket_index2 = bucket_index;
if (end)
{
if (this_bucket->next_ == prev)
this_bucket->next_ = node_pointer();
}
else
{
bucket_pointer next_bucket = get_bucket(
policy::to_bucket(bucket_count_, next->hash_));
bucket_index2 = hash_to_bucket(
static_cast<node_pointer>(end)->hash_);
if (next_bucket != this_bucket)
{
next_bucket->next_ = prev;
if (this_bucket->next_ == prev)
this_bucket->next_ = node_pointer();
}
}
}
// If begin and end are in the same bucket, then
// there's nothing to do.
if (bucket_index == bucket_index2) return bucket_index2;
// 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)
{
node_pointer n = begin;
// If we're not at the start of the current bucket, then
// go to the start of the next bucket.
if (get_bucket(bucket_index)->next_ != prev)
{
for(;;) {
n = static_cast<node_pointer>(n->next_);
if (n == end) {
if (n) {
std::size_t new_bucket_index =
policy::to_bucket(bucket_count_, n->hash_);
if (bucket_index != new_bucket_index) {
get_bucket(new_bucket_index)->next_ = prev;
}
}
return;
}
std::size_t new_bucket_index =
policy::to_bucket(bucket_count_, n->hash_);
if (bucket_index != new_bucket_index) {
bucket_index = new_bucket_index;
break;
}
}
// Update the bucket containing end.
get_bucket(bucket_index2)->next_ = prev;
}
// Iterate through the remaining nodes, clearing out the bucket
// pointers.
get_bucket(bucket_index)->next_ = previous_pointer();
for(;;) {
n = static_cast<node_pointer>(n->next_);
if (n == end) break;
// Check if this bucket is now empty.
bucket_pointer this_bucket = get_bucket(bucket_index);
if (this_bucket->next_ == prev)
this_bucket->next_ = link_pointer();
std::size_t new_bucket_index =
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();
}
};
// Finally fix the bucket containing the trailing node.
if (n) {
get_bucket(
policy::to_bucket(bucket_count_, n->hash_))->next_
= prev;
}
return bucket_index2;
}
////////////////////////////////////////////////////////////////////////