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

Add transparent_tests

Browse Source
This commit is contained in:
Christian Mazakas
2022-10-10 10:52:01 -07:00
parent 1ff2dc4042
commit 58b78f8ff0
4 changed files with 194 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
include/boost/unordered/unordered_flat_map.hpp
View File

@ -286,6 +286,15 @@ namespace boost {
size_type erase(key_type const& key) { return table_.erase(key); }
template <class K>
typename std::enable_if<
detail::transparent_non_iterable<K, unordered_flat_map>::value,
size_type>::type
erase(K const& key)
{
return table_.erase(key);
}
/// Lookup
///
@ -326,6 +335,15 @@ namespace boost {
return pos != table_.end() ? 1 : 0;
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
count(K const& key) const
{
auto pos = table_.find(key);
return pos != table_.end() ? 1 : 0;
}
iterator find(key_type const& key) { return table_.find(key); }
const_iterator find(key_type const& key) const
@ -390,6 +408,38 @@ namespace boost {
return {pos, next};
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value,
std::pair<iterator, iterator> >::type
equal_range(K const& key)
{
auto pos = table_.find(key);
if (pos == table_.end()) {
return {pos, pos};
}
auto next = pos;
++next;
return {pos, next};
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value,
std::pair<const_iterator, const_iterator> >::type
equal_range(K const& key) const
{
auto pos = table_.find(key);
if (pos == table_.end()) {
return {pos, pos};
}
auto next = pos;
++next;
return {pos, next};
}
/// Hash Policy
///

50
include/boost/unordered/unordered_flat_set.hpp
View File

@ -214,6 +214,15 @@ namespace boost {
size_type erase(key_type const& key) { return table_.erase(key); }
template <class K>
typename std::enable_if<
detail::transparent_non_iterable<K, unordered_flat_set>::value,
size_type>::type
erase(K const& key)
{
return table_.erase(key);
}
/// Lookup
///
@ -223,6 +232,15 @@ namespace boost {
return pos != table_.end() ? 1 : 0;
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
count(K const& key) const
{
auto pos = table_.find(key);
return pos != table_.end() ? 1 : 0;
}
iterator find(key_type const& key) { return table_.find(key); }
const_iterator find(key_type const& key) const
@ -287,6 +305,38 @@ namespace boost {
return {pos, next};
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value,
std::pair<iterator, iterator> >::type
equal_range(K const& key)
{
auto pos = table_.find(key);
if (pos == table_.end()) {
return {pos, pos};
}
auto next = pos;
++next;
return {pos, next};
}
template <class K>
typename std::enable_if<
detail::are_transparent<K, hasher, key_equal>::value,
std::pair<const_iterator, const_iterator> >::type
equal_range(K const& key) const
{
auto pos = table_.find(key);
if (pos == table_.end()) {
return {pos, pos};
}
auto next = pos;
++next;
return {pos, next};
}
/// Hash Policy
///

1
test/Jamfile.v2
View File

@ -114,5 +114,6 @@ build_foa find_tests ;
build_foa at_tests ;
build_foa load_factor_tests ;
build_foa rehash_tests ;
build_foa transparent_tests ;
build_foa contains_tests ;
build_foa equality_tests ;

109
test/unordered/transparent_tests.cpp
View File

@ -4,8 +4,14 @@
// clang-format off
#include "../helpers/prefix.hpp"
#ifdef BOOST_UNORDERED_FOA_TESTS
#include <boost/unordered_flat_set.hpp>
#include <boost/unordered_flat_map.hpp>
#include <boost/unordered/detail/implementation.hpp>
#else
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#endif
#include "../helpers/postfix.hpp"
// clang-format on
@ -1053,14 +1059,25 @@ template <class UnorderedMap> struct convertible_to_const_iterator
}
};
#ifdef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_map<int, int, transparent_hasher,
transparent_key_equal>
transparent_unordered_map;
#else
typedef boost::unordered_map<int, int, transparent_hasher,
transparent_key_equal>
transparent_unordered_map;
#endif
// test that in the presence of the member function template `erase()`, we still
// invoke the correct iterator overloads when the type is implicitly convertible
//
transparent_unordered_map::iterator map_erase_overload_compile_test()
#ifdef BOOST_UNORDERED_FOA_TESTS
void
#else
transparent_unordered_map::iterator
#endif
map_erase_overload_compile_test()
{
convertible_to_iterator<transparent_unordered_map> c;
transparent_unordered_map map;
@ -1069,7 +1086,11 @@ transparent_unordered_map::iterator map_erase_overload_compile_test()
return map.erase(c);
}
#ifdef BOOST_UNORDERED_FOA_TESTS
void
#else
transparent_unordered_map::const_iterator
#endif
map_erase_const_overload_compile_test()
{
convertible_to_const_iterator<transparent_unordered_map> c;
@ -1079,6 +1100,7 @@ map_erase_const_overload_compile_test()
return map.erase(c);
}
#ifndef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_multimap<int, int, transparent_hasher,
transparent_key_equal>
transparent_unordered_multimap;
@ -1101,6 +1123,7 @@ multimap_erase_const_overload_compile_test()
pos = c;
return map.erase(c);
}
#endif
template <class UnorderedMap> void test_map_transparent_erase()
{
@ -1197,14 +1220,25 @@ template <class UnorderedMap> void test_map_non_transparent_erase()
BOOST_TEST_EQ(key::count_, key_count);
}
#if BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_set<int, transparent_hasher,
transparent_key_equal>
transparent_unordered_set;
#else
typedef boost::unordered_set<int, transparent_hasher, transparent_key_equal>
transparent_unordered_set;
typedef boost::unordered_multiset<int, transparent_hasher,
transparent_key_equal>
transparent_unordered_multiset;
#endif
transparent_unordered_set::iterator set_erase_overload_compile_test()
#ifdef BOOST_UNORDERED_FOA_TESTS
void
#else
transparent_unordered_set::iterator
#endif
set_erase_overload_compile_test()
{
convertible_to_iterator<transparent_unordered_set> c;
transparent_unordered_set set;
@ -1213,7 +1247,11 @@ transparent_unordered_set::iterator set_erase_overload_compile_test()
return set.erase(c);
}
#ifdef BOOST_UNORDERED_FOA_TESTS
void
#else
transparent_unordered_set::const_iterator
#endif
set_erase_const_overload_compile_test()
{
convertible_to_const_iterator<transparent_unordered_set> c;
@ -1223,6 +1261,7 @@ set_erase_const_overload_compile_test()
return set.erase(c);
}
#ifndef BOOST_UNORDERED_FOA_TESTS
transparent_unordered_multiset::iterator multiset_erase_overload_compile_test()
{
convertible_to_iterator<transparent_unordered_multiset> c;
@ -1241,6 +1280,7 @@ multiset_erase_const_overload_compile_test()
pos = c;
return set.erase(c);
}
#endif
template <class UnorderedSet> void test_set_transparent_erase()
{
@ -1337,6 +1377,7 @@ template <class UnorderedSet> void test_set_non_transparent_erase()
BOOST_TEST_EQ(key::count_, key_count);
}
#ifndef BOOST_UNORDERED_FOA_TESTS
// test that in the presence of the member function template `extract()`, we
// still invoke the correct iterator overloads when the type is implicitly
// convertible
@ -1359,9 +1400,11 @@ multimap_extract_const_overload_compile_test()
pos = c;
return map.extract(c);
}
#endif
template <class UnorderedMap> void test_map_transparent_extract()
{
#ifndef BOOST_UNORDERED_FOA_TESTS
typedef typename UnorderedMap::node_type node_type;
typedef typename UnorderedMap::const_iterator const_iterator;
typedef std::pair<const_iterator, const_iterator> const_iterator_pair;
@ -1397,10 +1440,12 @@ template <class UnorderedMap> void test_map_transparent_extract()
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, expected_key_count);
#endif
}
template <class UnorderedMap> void test_map_non_transparent_extract()
{
#ifndef BOOST_UNORDERED_FOA_TESTS
typedef typename UnorderedMap::node_type node_type;
typedef typename UnorderedMap::const_iterator const_iterator;
typedef std::pair<const_iterator, const_iterator> const_iterator_pair;
@ -1441,8 +1486,10 @@ template <class UnorderedMap> void test_map_non_transparent_extract()
++key_count;
BOOST_TEST(nh.empty());
BOOST_TEST_EQ(key::count_, key_count);
#endif
}
#ifndef BOOST_UNORDERED_FOA_TESTS
transparent_unordered_set::node_type set_extract_overload_compile_test()
{
convertible_to_iterator<transparent_unordered_set> c;
@ -1480,9 +1527,11 @@ multiset_extract_const_overload_compile_test()
pos = c;
return set.extract(c);
}
#endif
template <class UnorderedSet> void test_set_transparent_extract()
{
#ifndef BOOST_UNORDERED_FOA_TESTS
typedef typename UnorderedSet::node_type node_type;
count_reset();
@ -1526,10 +1575,12 @@ template <class UnorderedSet> void test_set_transparent_extract()
BOOST_TEST_EQ(set.size(), set_size);
BOOST_TEST_EQ(key::count_, expected_key_count);
#endif
}
template <class UnorderedSet> void test_set_non_transparent_extract()
{
#ifndef BOOST_UNORDERED_FOA_TESTS
typedef typename UnorderedSet::node_type node_type;
count_reset();
@ -1583,14 +1634,23 @@ template <class UnorderedSet> void test_set_non_transparent_extract()
BOOST_TEST_EQ(set.size(), set_size);
BOOST_TEST_EQ(key::count_, key_count);
#endif
}
template <class Key, class T, class Hash, class KeyEqual> struct map_type
{
#ifdef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_map<Key, T, Hash, KeyEqual> type;
#else
typedef boost::unordered_map<Key, T, Hash, KeyEqual> type;
#endif
};
void test_unordered_map()
{
{
typedef boost::unordered_map<key, int, transparent_hasher,
transparent_key_equal>
unordered_map;
typedef typename map_type<key, int, transparent_hasher,
transparent_key_equal>::type unordered_map;
test_map_transparent_count<unordered_map>();
test_map_transparent_find<unordered_map>();
@ -1602,7 +1662,7 @@ void test_unordered_map()
{
// non-transparent Hash, non-transparent KeyEqual
//
typedef boost::unordered_map<key, int, hasher, key_equal> unordered_map;
typedef typename map_type<key, int, hasher, key_equal>::type unordered_map;
test_map_non_transparent_count<unordered_map>();
test_map_non_transparent_find<unordered_map>();
@ -1614,7 +1674,7 @@ void test_unordered_map()
{
// transparent Hash, non-transparent KeyEqual
//
typedef boost::unordered_map<key, int, transparent_hasher, key_equal>
typedef typename map_type<key, int, transparent_hasher, key_equal>::type
unordered_map;
test_map_non_transparent_count<unordered_map>();
@ -1627,7 +1687,7 @@ void test_unordered_map()
{
// non-transparent Hash, transparent KeyEqual
//
typedef boost::unordered_map<key, int, hasher, transparent_key_equal>
typedef typename map_type<key, int, hasher, transparent_key_equal>::type
unordered_map;
test_map_non_transparent_count<unordered_map>();
@ -1638,6 +1698,7 @@ void test_unordered_map()
}
}
#ifndef BOOST_UNORDERED_FOA_TESTS
void test_unordered_multimap()
{
{
@ -1691,12 +1752,23 @@ void test_unordered_multimap()
test_map_non_transparent_extract<unordered_multimap>();
}
}
#endif
template <class Key, class Hash, class KeyEqual> struct set_type
{
#ifdef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_set<Key, Hash, KeyEqual> type;
#else
typedef boost::unordered_set<Key, Hash, KeyEqual> type;
#endif
};
void test_unordered_set()
{
{
typedef boost::unordered_set<key, transparent_hasher, transparent_key_equal>
unordered_set;
typedef
typename set_type<key, transparent_hasher, transparent_key_equal>::type
unordered_set;
test_set_transparent_count<unordered_set>();
test_set_transparent_find<unordered_set>();
@ -1708,7 +1780,7 @@ void test_unordered_set()
{
// non-transparent Hash, non-transparent KeyEqual
//
typedef boost::unordered_set<key, hasher, key_equal> unordered_set;
typedef typename set_type<key, hasher, key_equal>::type unordered_set;
test_set_non_transparent_count<unordered_set>();
test_set_non_transparent_find<unordered_set>();
@ -1720,8 +1792,8 @@ void test_unordered_set()
{
// transparent Hash, non-transparent KeyEqual
//
typedef boost::unordered_set<key, transparent_hasher, key_equal>
unordered_set;
typedef
typename set_type<key, transparent_hasher, key_equal>::type unordered_set;
test_set_non_transparent_count<unordered_set>();
test_set_non_transparent_find<unordered_set>();
@ -1733,8 +1805,8 @@ void test_unordered_set()
{
// non-transparent Hash, transparent KeyEqual
//
typedef boost::unordered_set<key, hasher, transparent_key_equal>
unordered_set;
typedef
typename set_type<key, hasher, transparent_key_equal>::type unordered_set;
test_set_non_transparent_count<unordered_set>();
test_set_non_transparent_find<unordered_set>();
@ -1744,6 +1816,7 @@ void test_unordered_set()
}
}
#ifndef BOOST_UNORDERED_FOA_TESTS
void test_unordered_multiset()
{
{
@ -1796,12 +1869,16 @@ void test_unordered_multiset()
test_set_non_transparent_extract<unordered_set>();
}
}
#endif
UNORDERED_AUTO_TEST (transparent_ops) {
test_unordered_map();
test_unordered_multimap();
test_unordered_set();
#ifndef BOOST_UNORDERED_FOA_TESTS
test_unordered_multimap();
test_unordered_multiset();
#endif
}
RUN_TESTS()