boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-29 19:07:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #66 from cmazakas/set-heterogeneous-erase

Browse Source 
Set Heterogeneous `erase()`
This commit is contained in:
Peter Dimov
2021-12-24 02:28:40 +02:00
committed by GitHub
parent 79ab9800c0 9c07cf60a6
commit b6f8363023
3 changed files with 129 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3458,11 +3458,6 @@ namespace boost {
return 1;
}
std::size_t erase_key_unique(const_key_type& k)
{
return this->erase_key_unique_impl(this->key_eq(), k);
}
void erase_nodes_unique(node_pointer i, node_pointer j)
{
std::size_t bucket_index = this->node_bucket(i);

13
include/boost/unordered/unordered_set.hpp
View File

@ -436,6 +436,17 @@ namespace boost {
iterator erase(const_iterator);
size_type erase(const key_type&);
iterator erase(const_iterator, const_iterator);
template <class Key>
typename boost::enable_if_c<
detail::transparent_non_iterable<Key, unordered_set>::value,
size_type>::type
erase(BOOST_FWD_REF(Key) k)
{
return table_.erase_key_unique_impl(
this->key_eq(), boost::forward<Key>(k));
}
BOOST_UNORDERED_DEPRECATED("Use erase instead")
void quick_erase(const_iterator it) { erase(it); }
BOOST_UNORDERED_DEPRECATED("Use erase instead")
@ -1355,7 +1366,7 @@ namespace boost {
typename unordered_set<T, H, P, A>::size_type
unordered_set<T, H, P, A>::erase(const key_type& k)
{
return table_.erase_key_unique(k);
return table_.erase_key_unique_impl(this->key_eq(), k);
}
template <class T, class H, class P, class A>

127
test/unordered/transparent_tests.cpp
View File

@ -687,7 +687,7 @@ multimap_erase_const_overload_compile_test()
return map.erase(c);
}
template <class UnorderedMap> void test_transparent_erase()
template <class UnorderedMap> void test_map_transparent_erase()
{
count_reset();
@ -724,7 +724,7 @@ template <class UnorderedMap> void test_transparent_erase()
BOOST_TEST_EQ(key::count_, expected_key_count);
}
template <class UnorderedMap> void test_non_transparent_erase()
template <class UnorderedMap> void test_map_non_transparent_erase()
{
count_reset();
@ -768,6 +768,109 @@ template <class UnorderedMap> void test_non_transparent_erase()
BOOST_TEST_EQ(key::count_, key_count);
}
typedef boost::unordered_set<int, transparent_hasher, transparent_key_equal>
transparent_unordered_set;
transparent_unordered_set::iterator set_erase_overload_compile_test()
{
convertible_to_iterator<transparent_unordered_set> c;
transparent_unordered_set set;
transparent_unordered_set::iterator pos = set.begin();
pos = c;
return set.erase(c);
}
transparent_unordered_set::const_iterator
set_erase_const_overload_compile_test()
{
convertible_to_const_iterator<transparent_unordered_set> c;
transparent_unordered_set set;
transparent_unordered_set::const_iterator pos = set.begin();
pos = c;
return set.erase(c);
}
template <class UnorderedSet> void test_set_transparent_erase()
{
count_reset();
UnorderedSet set;
unsigned long num_erased = 0;
num_erased = set.erase(0);
BOOST_TEST(set.empty());
BOOST_TEST_EQ(num_erased, 0);
BOOST_TEST_EQ(key::count_, 0);
set.insert(0);
set.insert(1);
set.insert(2);
set.insert(0);
set.insert(0);
set.insert(0);
BOOST_TEST(set.find(0) != set.end());
int const expected_key_count = key::count_;
int const expected_num_erased = static_cast<int>(set.size() - 2);
num_erased = set.erase(0);
BOOST_TEST_EQ(num_erased, expected_num_erased);
BOOST_TEST_EQ(set.size(), 2);
BOOST_TEST(set.find(0) == set.end());
num_erased = set.erase(1337);
BOOST_TEST_EQ(num_erased, 0);
BOOST_TEST_EQ(set.size(), 2);
BOOST_TEST_EQ(key::count_, expected_key_count);
}
template <class UnorderedSet> void test_set_non_transparent_erase()
{
count_reset();
UnorderedSet set;
unsigned long num_erased = 0;
num_erased = set.erase(0);
BOOST_TEST(set.empty());
BOOST_TEST_EQ(num_erased, 0);
BOOST_TEST_EQ(key::count_, 1);
set.insert(0);
set.insert(1);
set.insert(2);
set.insert(0);
set.insert(0);
set.insert(0);
int const expected_num_erased = static_cast<int>(set.size() - 2);
BOOST_TEST(set.find(0) != set.end());
int key_count = key::count_;
num_erased = set.erase(0);
++key_count;
BOOST_TEST_EQ(key::count_, key_count);
BOOST_TEST_EQ(num_erased, expected_num_erased);
BOOST_TEST_EQ(set.size(), 2);
BOOST_TEST(set.find(0) == set.end());
++key_count;
BOOST_TEST_EQ(key::count_, key_count);
num_erased = set.erase(1337);
++key_count;
BOOST_TEST_EQ(num_erased, 0);
BOOST_TEST_EQ(set.size(), 2);
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
@ -884,7 +987,7 @@ void test_unordered_map()
test_transparent_count<unordered_map>();
test_map_transparent_find<unordered_map>();
test_transparent_equal_range<unordered_map>();
test_transparent_erase<unordered_map>();
test_map_transparent_erase<unordered_map>();
test_transparent_extract<unordered_map>();
}
@ -896,7 +999,7 @@ void test_unordered_map()
test_non_transparent_count<unordered_map>();
test_map_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_map_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
@ -909,7 +1012,7 @@ void test_unordered_map()
test_non_transparent_count<unordered_map>();
test_map_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_map_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
@ -922,7 +1025,7 @@ void test_unordered_map()
test_non_transparent_count<unordered_map>();
test_map_non_transparent_find<unordered_map>();
test_non_transparent_equal_range<unordered_map>();
test_non_transparent_erase<unordered_map>();
test_map_non_transparent_erase<unordered_map>();
test_non_transparent_extract<unordered_map>();
}
}
@ -937,7 +1040,7 @@ void test_unordered_multimap()
test_transparent_count<unordered_multimap>();
test_map_transparent_find<unordered_multimap>();
test_transparent_equal_range<unordered_multimap>();
test_transparent_erase<unordered_multimap>();
test_map_transparent_erase<unordered_multimap>();
test_transparent_extract<unordered_multimap>();
}
@ -950,7 +1053,7 @@ void test_unordered_multimap()
test_non_transparent_count<unordered_multimap>();
test_map_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>();
test_map_non_transparent_erase<unordered_multimap>();
test_non_transparent_extract<unordered_multimap>();
}
@ -963,7 +1066,7 @@ void test_unordered_multimap()
test_non_transparent_count<unordered_multimap>();
test_map_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>();
test_map_non_transparent_erase<unordered_multimap>();
test_non_transparent_extract<unordered_multimap>();
}
@ -976,7 +1079,7 @@ void test_unordered_multimap()
test_non_transparent_count<unordered_multimap>();
test_map_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>();
test_map_non_transparent_erase<unordered_multimap>();
test_non_transparent_extract<unordered_multimap>();
}
}
@ -988,6 +1091,7 @@ void test_unordered_set()
unordered_set;
test_set_transparent_find<unordered_set>();
test_set_transparent_erase<unordered_set>();
}
{
@ -996,6 +1100,7 @@ void test_unordered_set()
typedef boost::unordered_set<key, hasher, key_equal> unordered_set;
test_set_non_transparent_find<unordered_set>();
test_set_non_transparent_erase<unordered_set>();
}
{
@ -1005,6 +1110,7 @@ void test_unordered_set()
unordered_set;
test_set_non_transparent_find<unordered_set>();
test_set_non_transparent_erase<unordered_set>();
}
{
@ -1014,6 +1120,7 @@ void test_unordered_set()
unordered_set;
test_set_non_transparent_find<unordered_set>();
test_set_non_transparent_erase<unordered_set>();
}
}