Unordered: Faster assign implementation

[SVN r80380]
This commit is contained in:
Daniel James committed 2012-09-03 20:02:31 +00:00
1 parent 73c269398a
commit d9f49f2b44
2 files changed
+233 -34

No files matched your search

+121 -2
View File
@@ -51,7 +51,12 @@ namespace boost { namespace unordered { namespace detail {
typedef typename node_allocator_traits::pointer node_pointer;
typedef typename node::value_type value_type;
protected:
node_allocator& alloc_;
private:
node_pointer node_;
bool node_constructed_;
bool value_constructed_;
@@ -97,6 +102,7 @@ namespace boost { namespace unordered { namespace detail {
// no throw
node_pointer release()
{
BOOST_ASSERT(node_ && node_constructed_);
node_pointer p = node_;
node_ = node_pointer();
return p;
@@ -151,6 +157,114 @@ namespace boost { namespace unordered { namespace detail {
}
}
///////////////////////////////////////////////////////////////////
//
// Node Holder
//
// Temporary store for nodes. Deletes any that aren't used.
template <typename NodeAlloc>
struct node_holder : private node_constructor<NodeAlloc>
{
private:
typedef node_constructor<NodeAlloc> base;
typedef NodeAlloc node_allocator;
typedef boost::unordered::detail::allocator_traits<NodeAlloc>
node_allocator_traits;
typedef typename node_allocator_traits::value_type node;
typedef typename node_allocator_traits::pointer node_pointer;
typedef typename node::value_type value_type;
typedef typename node::link_pointer link_pointer;
node_pointer nodes_;
public:
template <typename Buckets>
explicit node_holder(Buckets& b) :
base(b.node_alloc()),
nodes_()
{
typename Buckets::previous_pointer prev = b.get_previous_start();
nodes_ = static_cast<node_pointer>(prev->next_);
prev->next_ = link_pointer();
b.size_ = 0;
}
~node_holder();
template <typename T>
inline void assign_impl(T const& v) {
nodes_->value() = v;
}
template <typename T1, typename T2>
inline void assign_impl(std::pair<T1 const, T2> const& v) {
const_cast<T1&>(nodes_->value().first) = v.first;
nodes_->value().second = v.second;
}
template <typename T>
inline void move_assign_impl(T& v) {
nodes_->value() = boost::move(v);
}
template <typename T1, typename T2>
inline void move_assign_impl(std::pair<T1 const, T2>& v) {
// TODO: Move key as well?
const_cast<T1&>(nodes_->value().first) =
boost::move(const_cast<T1&>(v.first));
nodes_->value().second = boost::move(v.second);
}
node_pointer copy_of(value_type const& v)
{
if (nodes_) {
assign_impl(v);
node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_);
p->next_ = link_pointer();
return p;
}
else {
this->construct_node();
this->construct_value2(v);
return base::release();
}
}
node_pointer move_copy_of(value_type& v)
{
if (nodes_) {
move_assign_impl(v);
node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_);
p->next_ = link_pointer();
return p;
}
else {
this->construct_node();
this->construct_value2(boost::move(v));
return base::release();
}
}
};
template <typename Alloc>
node_holder<Alloc>::~node_holder()
{
while (nodes_) {
node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_);
boost::unordered::detail::destroy_value_impl(this->alloc_,
p->value_ptr());
node_allocator_traits::destroy(this->alloc_, boost::addressof(*p));
node_allocator_traits::deallocate(this->alloc_, p, 1);
}
}
///////////////////////////////////////////////////////////////////
//
// Bucket
@@ -860,13 +974,18 @@ namespace boost { namespace unordered { namespace detail {
delete_node(iterator(n));
}
clear_buckets();
BOOST_ASSERT(!this->size_);
}
void clear_buckets()
{
bucket_pointer end = this->get_bucket(this->bucket_count_);
for(bucket_pointer it = this->buckets_; it != end; ++it)
{
it->next_ = node_pointer();
}
BOOST_ASSERT(!this->size_);
}
// This is called after erasing a node or group of nodes to fix up