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

Merge pull request #55 from LeonineKing1199/heterogeneous-extract

Browse Source 
Heterogeneous Extract
This commit is contained in:
Peter Dimov
2021-12-08 00:56:26 +02:00
committed by GitHub
parent 00b504ebc5 ea5cabb27f
commit 0c54f60e17
3 changed files with 145 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/boost/unordered/detail/implementation.hpp
View File

@ -3655,14 +3655,15 @@ namespace boost {
// Extract and erase
inline node_pointer extract_by_key(const_key_type& k)
template <class Key> node_pointer extract_by_key_impl(Key const& k)
{
if (!this->size_) {
return node_pointer();
}
std::size_t key_hash = this->hash(k);
std::size_t key_hash = policy::apply_hash(this->hash_function(), k);
std::size_t bucket_index = this->hash_to_bucket(key_hash);
link_pointer prev = this->find_previous_node(k, bucket_index);
link_pointer prev =
this->find_previous_node_impl(this->key_eq(), k, bucket_index);
if (!prev) {
return node_pointer();
}
@ -3679,6 +3680,11 @@ namespace boost {
return n;
}
inline node_pointer extract_by_key(const_key_type& k)
{
return extract_by_key_impl(k);
}
// Reserve and rehash
void reserve_for_insert(std::size_t);

15
include/boost/unordered/unordered_map.hpp
View File

@ -427,7 +427,20 @@ namespace boost {
node_type extract(const key_type& k)
{
return node_type(table_.extract_by_key(k), table_.node_alloc());
return node_type(table_.extract_by_key_impl(k), table_.node_alloc());
}
template <class Key>
typename boost::enable_if_c<
detail::is_transparent<Key, H>::value &&
detail::is_transparent<Key, P>::value &&
!boost::is_convertible<Key, iterator>::value &&
!boost::is_convertible<Key, const_iterator>::value,
node_type>::type
extract(BOOST_FWD_REF(Key) k)
{
return node_type(table_.extract_by_key_impl(boost::forward<Key>(k)),
table_.node_alloc());
}
insert_return_type insert(BOOST_RV_REF(node_type) np)

122
test/unordered/transparent_tests.cpp
View File

@ -528,6 +528,14 @@ template <class UnorderedMap> struct convertible_to_iterator
}
};
template <class UnorderedMap> struct convertible_to_const_iterator
{
operator typename UnorderedMap::const_iterator()
{
return typename UnorderedMap::const_iterator();
}
};
typedef boost::unordered_map<int, int, transparent_hasher,
transparent_key_equal>
transparent_unordered_map;
@ -544,6 +552,15 @@ transparent_unordered_map::iterator erase_overload_compile_test()
return map.erase(c);
}
transparent_unordered_map::const_iterator erase_const_overload_compile_test()
{
convertible_to_const_iterator<transparent_unordered_map> c;
transparent_unordered_map map;
transparent_unordered_map::const_iterator pos = map.begin();
pos = c;
return map.erase(c);
}
template <class UnorderedMap> void test_transparent_erase()
{
count_reset();
@ -620,6 +637,107 @@ template <class UnorderedMap> void test_non_transparent_erase()
BOOST_TEST_EQ(key::count_, key_count);
}
// test that in the presence of the member function template `extract()`, we
// still invoke the correct iterator overloads when the type is implicitly
// convertible
//
transparent_unordered_map::node_type extract_const_overload_compile_test()
{
convertible_to_const_iterator<transparent_unordered_map> c;
transparent_unordered_map map;
transparent_unordered_map::const_iterator pos = map.begin();
pos = c;
return map.extract(c);
}
template <class UnorderedMap> void test_transparent_extract()
{
typedef typename UnorderedMap::node_type node_type;
typedef typename UnorderedMap::const_iterator const_iterator;
count_reset();
UnorderedMap map;
node_type nh = map.extract(0);
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, 0);
map[key(0)] = 1337;
map[key(1)] = 1338;
map[key(2)] = 1339;
BOOST_TEST_EQ(map.size(), 3);
int const expected_key_count = static_cast<int>(2 * map.size());
BOOST_TEST_EQ(key::count_, expected_key_count);
nh = map.extract(1);
BOOST_TEST_EQ(map.size(), 2);
BOOST_TEST_EQ(nh.key().x_, 1);
BOOST_TEST_EQ(nh.mapped(), 1338);
nh.mapped() = 1340;
map.insert(boost::move(nh));
BOOST_TEST(map.size() == 3);
const_iterator pos = map.find(1);
BOOST_TEST(pos != map.end());
BOOST_TEST_EQ(pos->second, 1340);
nh = map.extract(1337);
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, expected_key_count);
}
template <class UnorderedMap> void test_non_transparent_extract()
{
typedef typename UnorderedMap::node_type node_type;
typedef typename UnorderedMap::const_iterator const_iterator;
count_reset();
UnorderedMap map;
node_type nh = map.extract(0);
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, 1);
map[key(0)] = 1337;
map[key(1)] = 1338;
map[key(2)] = 1339;
BOOST_TEST_EQ(map.size(), 3);
int key_count = 1 + static_cast<int>(2 * map.size());
BOOST_TEST_EQ(key::count_, key_count);
nh = map.extract(1);
++key_count;
BOOST_TEST_EQ(map.size(), 2);
BOOST_TEST_EQ(nh.key().x_, 1);
BOOST_TEST_EQ(nh.mapped(), 1338);
BOOST_TEST_EQ(key::count_, key_count);
nh.mapped() = 1340;
map.insert(boost::move(nh));
BOOST_TEST_EQ(map.size(), 3);
const_iterator pos = map.find(1);
++key_count;
BOOST_TEST(pos != map.end());
BOOST_TEST_EQ(pos->second, 1340);
BOOST_TEST_EQ(key::count_, key_count);
nh = map.extract(1337);
++key_count;
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, key_count);
}
UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
{
typedef boost::unordered_map<key, int, transparent_hasher,
@ -630,6 +748,7 @@ UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
test_transparent_find<unordered_map>();
test_transparent_equal_range<unordered_map>();
test_transparent_erase<unordered_map>();
test_transparent_extract<unordered_map>();
}
{
@ -641,6 +760,7 @@ UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
test_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
{
@ -653,6 +773,7 @@ UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
test_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
{
@ -665,6 +786,7 @@ UNORDERED_AUTO_TEST (unordered_map_transparent_count) {
test_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
}