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

Unordred: Implement propagate_on_container_swap.

Browse Source 
[SVN r73680]
This commit is contained in:
Daniel James
2011-08-11 21:18:43 +00:00
parent eacca89d4e
commit 0e5930b8dc
11 changed files with 95 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/boost/unordered/detail/allocator_helpers.hpp
View File

@@ -47,6 +47,12 @@ namespace boost { namespace unordered { namespace detail {
}}}
#endif
// TODO: Use std::addressof if available?
#include <boost/utility/addressof.hpp>
namespace boost { namespace unordered { namespace detail {
using boost::addressof;
}}}
namespace boost { namespace unordered { namespace detail {
#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
@@ -235,7 +241,7 @@ namespace boost { namespace unordered { namespace detail {
~allocator_array_constructor() {
if (ptr_) {
for(pointer p = ptr_; p != constructed_; ++p)
allocator_traits<Allocator>::destroy(alloc_, p);
allocator_traits<Allocator>::destroy(alloc_, addressof(*p));
allocator_traits<Allocator>::deallocate(alloc_, ptr_, length_);
}
@@ -249,7 +255,7 @@ namespace boost { namespace unordered { namespace detail {
ptr_ = allocator_traits<Allocator>::allocate(alloc_, length_);
pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
for(constructed_ = ptr_; constructed_ != end; ++constructed_)
allocator_traits<Allocator>::construct(alloc_, constructed_, v);
allocator_traits<Allocator>::construct(alloc_, addressof(*constructed_), v);
}
pointer get() const

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

@@ -106,9 +106,9 @@ namespace boost { namespace unordered { namespace detail {
// TODO: Need to move allocators_, not copy. But compressed_pair
// doesn't support move parameters.
buckets(buckets& b, move_tag m)
buckets(buckets& b, move_tag)
: buckets_(),
bucket_count_(b.bucket_count),
bucket_count_(b.bucket_count_),
allocators_(b.allocators_)
{
}
@@ -133,14 +133,20 @@ namespace boost { namespace unordered { namespace detail {
this->buckets_ = constructor.release();
}
// no throw
void swap(buckets& other)
void swap(buckets& other, false_type = false_type())
{
BOOST_ASSERT(node_alloc() == other.node_alloc());
std::swap(buckets_, other.buckets_);
std::swap(bucket_count_, other.bucket_count_);
}
void swap(buckets& other, true_type)
{
allocators_.swap(other.allocators_);
std::swap(buckets_, other.buckets_);
std::swap(bucket_count_, other.bucket_count_);
}
void move(buckets& other)
{
BOOST_ASSERT(node_alloc() == other.node_alloc());
@@ -189,11 +195,11 @@ namespace boost { namespace unordered { namespace detail {
void delete_node(node_ptr n)
{
node* raw_ptr = static_cast<node*>(&*n);
node* raw_ptr = static_cast<node*>(addressof(*n));
real_node_ptr real_ptr(node_alloc().address(*raw_ptr));
::boost::unordered::detail::destroy(raw_ptr->value_ptr());
allocator_traits<node_allocator>::destroy(node_alloc(), real_ptr);
allocator_traits<node_allocator>::destroy(node_alloc(), raw_ptr);
allocator_traits<node_allocator>::deallocate(node_alloc(), real_ptr, 1);
}
@@ -211,7 +217,7 @@ namespace boost { namespace unordered { namespace detail {
++end;
for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
allocator_traits<bucket_allocator>::destroy(bucket_alloc(), begin);
allocator_traits<bucket_allocator>::destroy(bucket_alloc(), addressof(*begin));
}
allocator_traits<bucket_allocator>::deallocate(bucket_alloc(), this->buckets_, this->bucket_count_ + 1);
@@ -580,7 +586,7 @@ namespace boost { namespace unordered { namespace detail {
}
if (node_constructed_)
allocator_traits<node_allocator>::destroy(buckets_.node_alloc(), node_);
allocator_traits<node_allocator>::destroy(buckets_.node_alloc(), addressof(*node_));
allocator_traits<node_allocator>::deallocate(buckets_.node_alloc(), node_, 1);
}
@@ -594,7 +600,7 @@ namespace boost { namespace unordered { namespace detail {
value_constructed_ = false;
node_ = allocator_traits<node_allocator>::allocate(buckets_.node_alloc(), 1);
allocator_traits<node_allocator>::construct(buckets_.node_alloc(), node_, node());
allocator_traits<node_allocator>::construct(buckets_.node_alloc(), addressof(*node_), node());
node_->init(buckets_.bucket_alloc().address(*node_));
node_constructed_ = true;

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

@@ -22,6 +22,7 @@ namespace boost { namespace unordered { namespace detail {
typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME T::table_base table_base;
typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator;
typedef BOOST_DEDUCED_TYPENAME T::node node;
typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;

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

@@ -176,8 +176,7 @@ namespace boost { namespace unordered { namespace detail {
////////////////////////////////////////////////////////////////////////
// Constructors
table(
std::size_t num_buckets,
table(std::size_t num_buckets,
hasher const& hf,
key_equal const& eq,
node_allocator const& a)
@@ -202,8 +201,8 @@ namespace boost { namespace unordered { namespace detail {
}
}
table(table& x, move_tag)
: buckets(boost::move(x.node_alloc()), x.bucket_count_),
table(table& x, move_tag m)
: buckets(x, m),
functions(x),
size_(0),
mlf_(1.0f),
@@ -254,69 +253,43 @@ namespace boost { namespace unordered { namespace detail {
void swap(table& x)
{
if(this->node_alloc() == x.node_alloc()) {
if(this != &x) this->fast_swap(x);
}
else {
this->slow_swap(x);
// TODO: Should I actually swap the buckets even if this
// is with self?
if(this != &x) {
{
set_hash_functions<hasher, key_equal> op1(*this, x);
set_hash_functions<hasher, key_equal> op2(x, *this);
this->buckets::swap(x, integral_constant<bool,
allocator_traits<node_allocator>::
propagate_on_container_swap::value>());
op1.commit();
op2.commit();
}
std::swap(this->size_, x.size_);
std::swap(this->mlf_, x.mlf_);
std::swap(this->max_load_, x.max_load_);
}
}
// Swap everything but the allocators
void fast_swap(table& x)
{
// These can throw, but they only affect the function objects
// that aren't in use so it is strongly exception safe, via.
// double buffering.
{
set_hash_functions<hasher, key_equal> op1(*this, x);
set_hash_functions<hasher, key_equal> op2(x, *this);
op1.commit();
op2.commit();
}
this->buckets::swap(x); // No throw
std::swap(this->size_, x.size_);
std::swap(this->mlf_, x.mlf_);
std::swap(this->max_load_, x.max_load_);
}
void slow_swap(table& x)
{
if(this == &x) return;
{
// These can throw, but they only affect the function objects
// that aren't in use so it is strongly exception safe, via.
// double buffering.
set_hash_functions<hasher, key_equal> op1(*this, x);
set_hash_functions<hasher, key_equal> op2(x, *this);
// Create new buckets in separate buckets objects
// which will clean up if anything throws an exception.
// (all can throw, but with no effect as these are new objects).
buckets b1(this->node_alloc(), x.min_buckets_for_size(x.size_));
if (x.size_) x.copy_buckets_to(b1);
buckets b2(x.node_alloc(), this->min_buckets_for_size(this->size_));
if (this->size_) this->copy_buckets_to(b2);
// Modifying the data, so no throw from now on.
b1.swap(*this);
b2.swap(x);
op1.commit();
op2.commit();
}
std::swap(this->size_, x.size_);
this->max_load_ = !this->buckets_ ? 0 : this->calculate_max_load();
x.max_load_ = !x.buckets_ ? 0 : x.calculate_max_load();
partial_swap(x);
}
// Swap everything but the allocators, and the functions objects.
void partial_swap(table& x)
{
this->buckets::swap(x); // No throw
this->buckets::swap(x, false_type());
std::swap(this->size_, x.size_);
std::swap(this->mlf_, x.mlf_);
std::swap(this->max_load_, x.max_load_);

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

@@ -22,6 +22,7 @@ namespace boost { namespace unordered { namespace detail {
typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME T::table_base table_base;
typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator;
typedef BOOST_DEDUCED_TYPENAME T::node node;
typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;