You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
706 lines
23 KiB
706 lines
23 KiB
|
|
// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard. |
|
// Copyright (C) 2005-2011 Daniel James |
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying |
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
#ifndef BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED |
|
#define BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED |
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020) |
|
# pragma once |
|
#endif |
|
|
|
#include <boost/unordered/detail/table.hpp> |
|
#include <boost/unordered/detail/emplace_args.hpp> |
|
#include <boost/unordered/detail/extract_key.hpp> |
|
#include <boost/throw_exception.hpp> |
|
#include <stdexcept> |
|
|
|
namespace boost { namespace unordered { namespace detail { |
|
|
|
template <typename A, typename T> struct node; |
|
template <typename T> struct ptr_node; |
|
template <typename Types> struct table_impl; |
|
|
|
template <typename A, typename T> |
|
struct node : |
|
boost::unordered::detail::value_base<T> |
|
{ |
|
typedef typename ::boost::unordered::detail::rebind_wrap< |
|
A, node<A, T> >::type::pointer link_pointer; |
|
|
|
link_pointer next_; |
|
std::size_t hash_; |
|
|
|
node() : |
|
next_(), |
|
hash_(0) |
|
{} |
|
|
|
void init(link_pointer) |
|
{ |
|
} |
|
}; |
|
|
|
template <typename T> |
|
struct ptr_node : |
|
boost::unordered::detail::value_base<T>, |
|
boost::unordered::detail::ptr_bucket |
|
{ |
|
typedef boost::unordered::detail::ptr_bucket bucket_base; |
|
typedef ptr_bucket* link_pointer; |
|
|
|
std::size_t hash_; |
|
|
|
ptr_node() : |
|
bucket_base(), |
|
hash_(0) |
|
{} |
|
|
|
void init(link_pointer) |
|
{ |
|
} |
|
}; |
|
|
|
// If the allocator uses raw pointers use ptr_node |
|
// Otherwise use node. |
|
|
|
template <typename A, typename T, typename NodePtr, typename BucketPtr> |
|
struct pick_node2 |
|
{ |
|
typedef boost::unordered::detail::node<A, T> node; |
|
|
|
typedef typename boost::unordered::detail::allocator_traits< |
|
typename boost::unordered::detail::rebind_wrap<A, node>::type |
|
>::pointer node_pointer; |
|
|
|
typedef boost::unordered::detail::bucket<node_pointer> bucket; |
|
typedef node_pointer link_pointer; |
|
}; |
|
|
|
template <typename A, typename T> |
|
struct pick_node2<A, T, |
|
boost::unordered::detail::ptr_node<T>*, |
|
boost::unordered::detail::ptr_bucket*> |
|
{ |
|
typedef boost::unordered::detail::ptr_node<T> node; |
|
typedef boost::unordered::detail::ptr_bucket bucket; |
|
typedef bucket* link_pointer; |
|
}; |
|
|
|
template <typename A, typename T> |
|
struct pick_node |
|
{ |
|
typedef boost::unordered::detail::allocator_traits< |
|
typename boost::unordered::detail::rebind_wrap<A, |
|
boost::unordered::detail::ptr_node<T> >::type |
|
> tentative_node_traits; |
|
|
|
typedef boost::unordered::detail::allocator_traits< |
|
typename boost::unordered::detail::rebind_wrap<A, |
|
boost::unordered::detail::ptr_bucket >::type |
|
> tentative_bucket_traits; |
|
|
|
typedef pick_node2<A, T, |
|
typename tentative_node_traits::pointer, |
|
typename tentative_bucket_traits::pointer> pick; |
|
|
|
typedef typename pick::node node; |
|
typedef typename pick::bucket bucket; |
|
typedef typename pick::link_pointer link_pointer; |
|
}; |
|
|
|
template <typename A, typename H, typename P> |
|
struct set |
|
{ |
|
typedef boost::unordered::detail::set<A, H, P> types; |
|
|
|
typedef A allocator; |
|
typedef H hasher; |
|
typedef P key_equal; |
|
|
|
typedef boost::unordered::detail::allocator_traits<A> traits; |
|
typedef typename traits::value_type value_type; |
|
typedef value_type key_type; |
|
|
|
typedef boost::unordered::detail::pick_node<A, value_type> pick; |
|
typedef typename pick::node node; |
|
typedef typename pick::bucket bucket; |
|
typedef typename pick::link_pointer link_pointer; |
|
|
|
typedef boost::unordered::detail::table_impl<types> table; |
|
typedef boost::unordered::detail::set_extractor<value_type> extractor; |
|
}; |
|
|
|
template <typename A, typename K, typename H, typename P> |
|
struct map |
|
{ |
|
typedef boost::unordered::detail::map<A, K, H, P> types; |
|
|
|
typedef A allocator; |
|
typedef H hasher; |
|
typedef P key_equal; |
|
typedef K key_type; |
|
|
|
typedef boost::unordered::detail::allocator_traits<A> traits; |
|
typedef typename traits::value_type value_type; |
|
|
|
typedef boost::unordered::detail::pick_node<A, value_type> pick; |
|
typedef typename pick::node node; |
|
typedef typename pick::bucket bucket; |
|
typedef typename pick::link_pointer link_pointer; |
|
|
|
typedef boost::unordered::detail::table_impl<types> table; |
|
typedef boost::unordered::detail::map_extractor<key_type, value_type> |
|
extractor; |
|
}; |
|
|
|
template <typename Types> |
|
struct table_impl : boost::unordered::detail::table<Types> |
|
{ |
|
typedef boost::unordered::detail::table<Types> table; |
|
typedef typename table::value_type value_type; |
|
typedef typename table::bucket bucket; |
|
typedef typename table::buckets buckets; |
|
typedef typename table::node_pointer node_pointer; |
|
typedef typename table::node_allocator node_allocator; |
|
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; |
|
typedef typename table::node_constructor node_constructor; |
|
typedef typename table::extractor extractor; |
|
typedef typename table::iterator iterator; |
|
|
|
typedef std::pair<iterator, bool> emplace_return; |
|
|
|
// Constructors |
|
|
|
table_impl(std::size_t n, |
|
hasher const& hf, |
|
key_equal const& eq, |
|
node_allocator const& a) |
|
: table(n, hf, eq, a) |
|
{} |
|
|
|
table_impl(table_impl const& x) |
|
: table(x, node_allocator_traits:: |
|
select_on_container_copy_construction(x.node_alloc())) {} |
|
|
|
table_impl(table_impl const& x, |
|
node_allocator const& a) |
|
: table(x, a) |
|
{} |
|
|
|
table_impl(table_impl& x, |
|
boost::unordered::detail::move_tag m) |
|
: table(x, m) |
|
{} |
|
|
|
table_impl(table_impl& x, |
|
node_allocator const& a, |
|
boost::unordered::detail::move_tag m) |
|
: table(x, a, m) |
|
{} |
|
|
|
// Accessors |
|
|
|
template <class Key, class Pred> |
|
node_pointer find_node_impl( |
|
std::size_t hash, |
|
Key const& k, |
|
Pred const& eq) const |
|
{ |
|
std::size_t bucket_index = hash % this->bucket_count_; |
|
node_pointer n = this->get_start(bucket_index); |
|
|
|
for (;;) |
|
{ |
|
if (!n) return n; |
|
|
|
std::size_t node_hash = n->hash_; |
|
if (hash == node_hash) |
|
{ |
|
if (eq(k, this->get_key(n->value()))) |
|
return n; |
|
} |
|
else |
|
{ |
|
if (node_hash % this->bucket_count_ != bucket_index) |
|
return node_pointer(); |
|
} |
|
|
|
n = static_cast<node_pointer>(n->next_); |
|
} |
|
} |
|
|
|
std::size_t count(key_type const& k) const |
|
{ |
|
return this->find_node(k) ? 1 : 0; |
|
} |
|
|
|
value_type& at(key_type const& k) const |
|
{ |
|
if (this->size_) { |
|
node_pointer it = this->find_node(k); |
|
if (it) return it->value(); |
|
} |
|
|
|
boost::throw_exception( |
|
std::out_of_range("Unable to find key in unordered_map.")); |
|
} |
|
|
|
std::pair<iterator, iterator> |
|
equal_range(key_type const& k) const |
|
{ |
|
node_pointer n = this->find_node(k); |
|
return std::make_pair(iterator(n), |
|
iterator(n ? static_cast<node_pointer>(n->next_) : n)); |
|
} |
|
|
|
// equals |
|
|
|
bool equals(table_impl const& other) const |
|
{ |
|
if(this->size_ != other.size_) return false; |
|
if(!this->size_) return true; |
|
|
|
for(node_pointer n1 = this->get_start(); n1; |
|
n1 = static_cast<node_pointer>(n1->next_)) |
|
{ |
|
node_pointer n2 = other.find_matching_node(n1); |
|
|
|
#if !defined(BOOST_UNORDERED_DEPRECATED_EQUALITY) |
|
if(!n2 || n1->value() != n2->value()) |
|
return false; |
|
#else |
|
if(!n2 || !extractor::compare_mapped( |
|
n1->value(), n2->value())) |
|
return false; |
|
#endif |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// Emplace/Insert |
|
|
|
inline node_pointer add_node( |
|
node_constructor& a, |
|
std::size_t hash) |
|
{ |
|
node_pointer n = a.release(); |
|
n->hash_ = hash; |
|
|
|
bucket_pointer b = this->get_bucket(hash % this->bucket_count_); |
|
|
|
if (!b->next_) |
|
{ |
|
previous_pointer start_node = this->get_previous_start(); |
|
|
|
if (start_node->next_) { |
|
this->get_bucket( |
|
static_cast<node_pointer>(start_node->next_)->hash_ % |
|
this->bucket_count_)->next_ = n; |
|
} |
|
|
|
b->next_ = start_node; |
|
n->next_ = start_node->next_; |
|
start_node->next_ = static_cast<link_pointer>(n); |
|
} |
|
else |
|
{ |
|
n->next_ = b->next_->next_; |
|
b->next_->next_ = static_cast<link_pointer>(n); |
|
} |
|
|
|
++this->size_; |
|
return n; |
|
} |
|
|
|
value_type& operator[](key_type const& k) |
|
{ |
|
typedef typename value_type::second_type mapped_type; |
|
|
|
std::size_t hash = this->hash_function()(k); |
|
node_pointer pos = this->find_node(hash, k); |
|
|
|
if (pos) return pos->value(); |
|
|
|
// Create the node before rehashing in case it throws an |
|
// exception (need strong safety in such a case). |
|
node_constructor a(this->node_alloc()); |
|
a.construct_node(); |
|
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE) |
|
a.construct_value(boost::unordered::piecewise_construct, |
|
boost::make_tuple(k), boost::make_tuple()); |
|
#else |
|
a.construct_value( |
|
boost::unordered::detail::create_emplace_args( |
|
boost::unordered::piecewise_construct, |
|
boost::make_tuple(k), |
|
boost::make_tuple())); |
|
#endif |
|
|
|
this->reserve_for_insert(this->size_ + 1); |
|
return add_node(a, hash)->value(); |
|
} |
|
|
|
#if defined(BOOST_NO_RVALUE_REFERENCES) |
|
emplace_return emplace(boost::unordered::detail::emplace_args1< |
|
boost::unordered::detail::please_ignore_this_overload> const&) |
|
{ |
|
BOOST_ASSERT(false); |
|
return emplace_return(iterator(this->begin()), false); |
|
} |
|
#endif |
|
|
|
template <BOOST_UNORDERED_EMPLACE_TEMPLATE> |
|
emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS) |
|
{ |
|
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE) |
|
return emplace_impl( |
|
extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD), |
|
BOOST_UNORDERED_EMPLACE_FORWARD); |
|
|
|
#else |
|
return emplace_impl( |
|
extractor::extract(args.a0, args.a1), |
|
BOOST_UNORDERED_EMPLACE_FORWARD); |
|
#endif |
|
} |
|
|
|
#if !defined(BOOST_UNORDERED_STD_FORWARD_MOVE) |
|
template <typename A0> |
|
emplace_return emplace( |
|
boost::unordered::detail::emplace_args1<A0> const& args) |
|
{ |
|
return emplace_impl(extractor::extract(args.a0), args); |
|
} |
|
#endif |
|
|
|
template <BOOST_UNORDERED_EMPLACE_TEMPLATE> |
|
emplace_return emplace_impl(key_type const& k, |
|
BOOST_UNORDERED_EMPLACE_ARGS) |
|
{ |
|
std::size_t hash = this->hash_function()(k); |
|
node_pointer pos = this->find_node(hash, k); |
|
|
|
if (pos) return emplace_return(iterator(pos), false); |
|
|
|
// Create the node before rehashing in case it throws an |
|
// exception (need strong safety in such a case). |
|
node_constructor a(this->node_alloc()); |
|
a.construct_node(); |
|
a.construct_value(BOOST_UNORDERED_EMPLACE_FORWARD); |
|
|
|
// reserve has basic exception safety if the hash function |
|
// throws, strong otherwise. |
|
this->reserve_for_insert(this->size_ + 1); |
|
return emplace_return(iterator(this->add_node(a, hash)), true); |
|
} |
|
|
|
emplace_return emplace_impl_with_node(node_constructor& a) |
|
{ |
|
key_type const& k = this->get_key(a.value()); |
|
std::size_t hash = this->hash_function()(k); |
|
node_pointer pos = this->find_node(hash, k); |
|
|
|
if (pos) return emplace_return(iterator(pos), false); |
|
|
|
// reserve has basic exception safety if the hash function |
|
// throws, strong otherwise. |
|
this->reserve_for_insert(this->size_ + 1); |
|
return emplace_return(iterator(this->add_node(a, hash)), true); |
|
} |
|
|
|
template <BOOST_UNORDERED_EMPLACE_TEMPLATE> |
|
emplace_return emplace_impl(no_key, BOOST_UNORDERED_EMPLACE_ARGS) |
|
{ |
|
// Don't have a key, so construct the node first in order |
|
// to be able to lookup the position. |
|
node_constructor a(this->node_alloc()); |
|
a.construct_node(); |
|
a.construct_value(BOOST_UNORDERED_EMPLACE_FORWARD); |
|
return emplace_impl_with_node(a); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
// Insert range methods |
|
// |
|
// if hash function throws, or inserting > 1 element, basic exception |
|
// safety strong otherwise |
|
|
|
template <class InputIt> |
|
void insert_range(InputIt i, InputIt j) |
|
{ |
|
if(i != j) |
|
return insert_range_impl(extractor::extract(*i), i, j); |
|
} |
|
|
|
template <class InputIt> |
|
void insert_range_impl(key_type const& k, InputIt i, InputIt j) |
|
{ |
|
node_constructor a(this->node_alloc()); |
|
|
|
// Special case for empty buckets so that we can use |
|
// max_load_ (which isn't valid when buckets_ is null). |
|
if (!this->buckets_) { |
|
insert_range_empty(a, k, i, j); |
|
if (++i == j) return; |
|
} |
|
|
|
do { |
|
// Note: can't use get_key as '*i' might not be value_type - it |
|
// could be a pair with first_types as key_type without const or |
|
// a different second_type. |
|
// |
|
// TODO: Might be worth storing the value_type instead of the |
|
// key here. Could be more efficient if '*i' is expensive. Could |
|
// be less efficient if copying the full value_type is |
|
// expensive. |
|
insert_range_impl2(a, extractor::extract(*i), i, j); |
|
} while(++i != j); |
|
} |
|
|
|
template <class InputIt> |
|
void insert_range_empty(node_constructor& a, key_type const& k, |
|
InputIt i, InputIt j) |
|
{ |
|
std::size_t hash = this->hash_function()(k); |
|
a.construct_node(); |
|
a.construct_value2(*i); |
|
this->reserve_for_insert(this->size_ + |
|
boost::unordered::detail::insert_size(i, j)); |
|
this->add_node(a, hash); |
|
} |
|
|
|
template <class InputIt> |
|
void insert_range_impl2(node_constructor& a, key_type const& k, |
|
InputIt i, InputIt j) |
|
{ |
|
// No side effects in this initial code |
|
std::size_t hash = this->hash_function()(k); |
|
node_pointer pos = this->find_node(hash, k); |
|
|
|
if (!pos) { |
|
a.construct_node(); |
|
a.construct_value2(*i); |
|
|
|
if(this->size_ + 1 >= this->max_load_) |
|
this->reserve_for_insert(this->size_ + |
|
boost::unordered::detail::insert_size(i, j)); |
|
|
|
// Nothing after this point can throw. |
|
this->add_node(a, hash); |
|
} |
|
} |
|
|
|
template <class InputIt> |
|
void insert_range_impl(no_key, InputIt i, InputIt j) |
|
{ |
|
node_constructor a(this->node_alloc()); |
|
|
|
do { |
|
a.construct_node(); |
|
a.construct_value2(*i); |
|
emplace_impl_with_node(a); |
|
} while(++i != j); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
// Erase |
|
// |
|
// no throw |
|
|
|
std::size_t erase_key(key_type const& k) |
|
{ |
|
if(!this->size_) return 0; |
|
|
|
std::size_t hash = this->hash_function()(k); |
|
std::size_t bucket_index = hash % this->bucket_count_; |
|
bucket_pointer bucket = this->get_bucket(bucket_index); |
|
|
|
previous_pointer prev = bucket->next_; |
|
if (!prev) return 0; |
|
|
|
for (;;) |
|
{ |
|
if (!prev->next_) return 0; |
|
std::size_t node_hash = |
|
static_cast<node_pointer>(prev->next_)->hash_; |
|
if (node_hash % this->bucket_count_ != bucket_index) |
|
return 0; |
|
if (node_hash == hash && |
|
this->key_eq()(k, this->get_key( |
|
static_cast<node_pointer>(prev->next_)->value()))) |
|
break; |
|
prev = static_cast<previous_pointer>(prev->next_); |
|
} |
|
|
|
node_pointer pos = static_cast<node_pointer>(prev->next_); |
|
node_pointer end = static_cast<node_pointer>(pos->next_); |
|
prev->next_ = pos->next_; |
|
this->fix_buckets(bucket, prev, end); |
|
return this->delete_nodes(pos, end); |
|
} |
|
|
|
node_pointer erase(node_pointer r) |
|
{ |
|
BOOST_ASSERT(r); |
|
node_pointer next = static_cast<node_pointer>(r->next_); |
|
|
|
bucket_pointer bucket = this->get_bucket( |
|
r->hash_ % this->bucket_count_); |
|
previous_pointer prev = unlink_node(*bucket, r); |
|
|
|
this->fix_buckets(bucket, prev, next); |
|
|
|
this->delete_node(r); |
|
|
|
return next; |
|
} |
|
|
|
node_pointer erase_range(node_pointer r1, node_pointer r2) |
|
{ |
|
if (r1 == r2) return r2; |
|
|
|
std::size_t bucket_index = r1->hash_ % this->bucket_count_; |
|
previous_pointer prev = unlink_nodes( |
|
*this->get_bucket(bucket_index), r1, r2); |
|
this->fix_buckets_range(bucket_index, prev, r1, r2); |
|
this->delete_nodes(r1, r2); |
|
|
|
return r2; |
|
} |
|
|
|
static previous_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, |
|
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); |
|
return prev; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
// copy_buckets_to |
|
// |
|
// Basic exception safety. If an exception is thrown this will |
|
// leave dst partially filled and the buckets unset. |
|
|
|
static void copy_buckets_to(buckets const& src, buckets& dst) |
|
{ |
|
BOOST_ASSERT(!dst.buckets_); |
|
|
|
dst.create_buckets(); |
|
|
|
node_constructor a(dst.node_alloc()); |
|
|
|
node_pointer n = src.get_start(); |
|
previous_pointer prev = dst.get_previous_start(); |
|
|
|
while(n) { |
|
a.construct_node(); |
|
a.construct_value2(n->value()); |
|
|
|
node_pointer node = a.release(); |
|
node->hash_ = n->hash_; |
|
prev->next_ = static_cast<link_pointer>(node); |
|
++dst.size_; |
|
n = static_cast<node_pointer>(n->next_); |
|
|
|
prev = place_in_bucket(dst, prev); |
|
} |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
// move_buckets_to |
|
// |
|
// Basic exception safety. The source nodes are left in an unusable |
|
// state if an exception throws. |
|
|
|
static void move_buckets_to(buckets& src, buckets& dst) |
|
{ |
|
BOOST_ASSERT(!dst.buckets_); |
|
|
|
dst.create_buckets(); |
|
|
|
node_constructor a(dst.node_alloc()); |
|
|
|
node_pointer n = src.get_start(); |
|
previous_pointer prev = dst.get_previous_start(); |
|
|
|
while(n) { |
|
a.construct_node(); |
|
a.construct_value2(boost::move(n->value())); |
|
|
|
node_pointer node = a.release(); |
|
node->hash_ = n->hash_; |
|
prev->next_ = static_cast<link_pointer>(node); |
|
++dst.size_; |
|
n = static_cast<node_pointer>(n->next_); |
|
|
|
prev = place_in_bucket(dst, prev); |
|
} |
|
} |
|
|
|
// strong otherwise exception safety |
|
void rehash_impl(std::size_t num_buckets) |
|
{ |
|
BOOST_ASSERT(this->size_); |
|
|
|
buckets dst(this->node_alloc(), num_buckets); |
|
dst.create_buckets(); |
|
|
|
previous_pointer src_start = this->get_previous_start(); |
|
previous_pointer dst_start = dst.get_previous_start(); |
|
|
|
dst_start->next_ = src_start->next_; |
|
src_start->next_ = link_pointer(); |
|
dst.size_ = this->size_; |
|
this->size_ = 0; |
|
|
|
previous_pointer prev = dst.get_previous_start(); |
|
while (prev->next_) |
|
prev = place_in_bucket(dst, prev); |
|
|
|
// Swap the new nodes back into the container and setup the |
|
// variables. |
|
dst.swap(*this); // no throw |
|
} |
|
|
|
// Iterate through the nodes placing them in the correct buckets. |
|
// pre: prev->next_ is not null. |
|
static previous_pointer place_in_bucket(buckets& dst, |
|
previous_pointer prev) |
|
{ |
|
node_pointer n = static_cast<node_pointer>(prev->next_); |
|
bucket_pointer b = dst.get_bucket(n->hash_ % dst.bucket_count_); |
|
|
|
if (!b->next_) { |
|
b->next_ = prev; |
|
return static_cast<previous_pointer>(n); |
|
} |
|
else { |
|
prev->next_ = n->next_; |
|
n->next_ = b->next_->next_; |
|
b->next_->next_ = static_cast<link_pointer>(n); |
|
return prev; |
|
} |
|
} |
|
}; |
|
}}} |
|
|
|
#endif
|
|
|