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

Merge pull request #64 from cmazakas/multimap-heterogeneous-count

Browse Source 
Multimap Heterogeneous `count()`
This commit is contained in:
Peter Dimov
2021-12-23 01:26:26 +02:00
committed by GitHub
parent e667e6dbd9 77c4a09a9b
commit c761934868
2 changed files with 51 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1487,6 +1487,18 @@ namespace boost {
size_type count(const key_type&) const; size_type count(const key_type&) const;
template <class Key>
typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
size_type>::type
count(const Key& k) const
{
node_pointer n = table_.find_node_impl(
table::policy::apply_hash(this->hash_function(), k), k,
this->key_eq());
return n ? table_.group_count(n) : 0;
}
std::pair<iterator, iterator> equal_range(const key_type&); std::pair<iterator, iterator> equal_range(const key_type&);
std::pair<const_iterator, const_iterator> equal_range( std::pair<const_iterator, const_iterator> equal_range(
const key_type&) const; const key_type&) const;

104
test/unordered/transparent_tests.cpp
View File

@ -40,23 +40,11 @@ struct transparent_key_equal
{ {
typedef void is_transparent; typedef void is_transparent;
static bool was_called_;
bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; } bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; }
bool operator()(int const x, key const& k1) const bool operator()(int const x, key const& k1) const { return k1.x_ == x; }
{ bool operator()(key const& k1, int const x) const { return k1.x_ == x; }
was_called_ = true;
return k1.x_ == x;
}
bool operator()(key const& k1, int const x) const
{
was_called_ = true;
return k1.x_ == x;
}
}; };
bool transparent_key_equal::was_called_;
struct hasher struct hasher
{ {
std::size_t operator()(key const& k) const std::size_t operator()(key const& k) const
@ -67,24 +55,10 @@ struct hasher
struct key_equal struct key_equal
{ {
static bool was_called_;
bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; } bool operator()(key const& k1, key const& k2) const { return k1.x_ == k2.x_; }
bool operator()(int const x, key const& k1) const
{
was_called_ = true;
return k1.x_ == x;
}
}; };
bool key_equal::was_called_; void count_reset() { key::count_ = 0; }
void count_reset()
{
key::count_ = 0;
transparent_key_equal::was_called_ = false;
key_equal::was_called_ = false;
}
template <class UnorderedMap> void test_transparent_count() template <class UnorderedMap> void test_transparent_count()
{ {
@ -92,31 +66,26 @@ template <class UnorderedMap> void test_transparent_count()
UnorderedMap map; UnorderedMap map;
// initial `key(0)` expression increases the count map.insert(std::make_pair(0, 1337));
// then copying into the `unordered_map` increments the count again thus we map.insert(std::make_pair(1, 1338));
// have 2 map.insert(std::make_pair(2, 1339));
// map.insert(std::make_pair(0, 1340));
map[key(0)] = 1337; map.insert(std::make_pair(0, 1341));
BOOST_TEST(key::count_ == 2); map.insert(std::make_pair(0, 1342));
int const expected_key_count = key::count_;
// now the number of `key` objects created should be a constant and never
// touched again
//
std::size_t count = 0; std::size_t count = 0;
count = map.count(0); count = map.count(0);
BOOST_TEST_EQ(count, map.size() - 2);
BOOST_TEST(count == 1);
BOOST_TEST(key::count_ == 2);
BOOST_TEST(map.key_eq().was_called_);
count = map.count(1); count = map.count(1);
BOOST_TEST_EQ(count, 1);
BOOST_TEST(count == 0); count = map.count(1337);
BOOST_TEST(key::count_ == 2); BOOST_TEST_EQ(count, 0);
count = map.count(key(0)); BOOST_TEST_EQ(key::count_, expected_key_count);
BOOST_TEST(count == 1);
BOOST_TEST(key::count_ == 3);
} }
template <class UnorderedMap> void test_non_transparent_count() template <class UnorderedMap> void test_non_transparent_count()
@ -125,31 +94,32 @@ template <class UnorderedMap> void test_non_transparent_count()
UnorderedMap map; UnorderedMap map;
// initial `key(0)` expression increases the count map.insert(std::make_pair(0, 1337));
// then copying into the `unordered_map` increments the count again thus we map.insert(std::make_pair(1, 1338));
// have 2 map.insert(std::make_pair(2, 1339));
// map.insert(std::make_pair(0, 1340));
map[key(0)] = 1337; map.insert(std::make_pair(0, 1341));
BOOST_TEST(key::count_ == 2); map.insert(std::make_pair(0, 1342));
int key_count = key::count_;
// rely on the implicit constructor here to spawn a new object which
// increases the count
//
std::size_t count = 0; std::size_t count = 0;
count = map.count(0); count = map.count(0);
++key_count;
BOOST_TEST(count == 1); BOOST_TEST_EQ(count, map.size() - 2);
BOOST_TEST(key::count_ == 3); BOOST_TEST_EQ(key::count_, key_count);
BOOST_TEST(!map.key_eq().was_called_);
count = map.count(1); count = map.count(1);
++key_count;
BOOST_TEST(count == 0); BOOST_TEST_EQ(count, 1);
BOOST_TEST(key::count_ == 4);
count = map.count(key(0)); count = map.count(1337);
BOOST_TEST(count == 1); ++key_count;
BOOST_TEST(key::count_ == 5);
BOOST_TEST_EQ(count, 0);
BOOST_TEST_EQ(key::count_, key_count);
} }
template <class UnorderedMap> void test_transparent_find() template <class UnorderedMap> void test_transparent_find()
@ -772,7 +742,7 @@ template <class UnorderedMap> void test_non_transparent_extract()
const_iterator_pair rng = map.equal_range(0); const_iterator_pair rng = map.equal_range(0);
++key_count; ++key_count;
for (const_iterator pos = rng.first; pos != rng.second; ++pos) { for (const_iterator pos = rng.first; pos != rng.second; ++pos) {
BOOST_TEST_NE(pos->second, nh.mapped()); BOOST_TEST_NE(pos->second, nh.mapped());
} }
@ -843,6 +813,7 @@ void test_unordered_multimap()
transparent_key_equal> transparent_key_equal>
unordered_multimap; unordered_multimap;
test_transparent_count<unordered_multimap>();
test_transparent_find<unordered_multimap>(); test_transparent_find<unordered_multimap>();
test_transparent_equal_range<unordered_multimap>(); test_transparent_equal_range<unordered_multimap>();
test_transparent_erase<unordered_multimap>(); test_transparent_erase<unordered_multimap>();
@ -855,6 +826,7 @@ void test_unordered_multimap()
typedef boost::unordered_multimap<key, int, hasher, key_equal> typedef boost::unordered_multimap<key, int, hasher, key_equal>
unordered_multimap; unordered_multimap;
test_non_transparent_count<unordered_multimap>();
test_non_transparent_find<unordered_multimap>(); test_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>(); test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>(); test_non_transparent_erase<unordered_multimap>();
@ -867,6 +839,7 @@ void test_unordered_multimap()
typedef boost::unordered_multimap<key, int, transparent_hasher, key_equal> typedef boost::unordered_multimap<key, int, transparent_hasher, key_equal>
unordered_multimap; unordered_multimap;
test_non_transparent_count<unordered_multimap>();
test_non_transparent_find<unordered_multimap>(); test_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>(); test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>(); test_non_transparent_erase<unordered_multimap>();
@ -879,6 +852,7 @@ void test_unordered_multimap()
typedef boost::unordered_multimap<key, int, hasher, transparent_key_equal> typedef boost::unordered_multimap<key, int, hasher, transparent_key_equal>
unordered_multimap; unordered_multimap;
test_non_transparent_count<unordered_multimap>();
test_non_transparent_find<unordered_multimap>(); test_non_transparent_find<unordered_multimap>();
test_non_transparent_equal_range<unordered_multimap>(); test_non_transparent_equal_range<unordered_multimap>();
test_non_transparent_erase<unordered_multimap>(); test_non_transparent_erase<unordered_multimap>();