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

Add insert_or_cvisit() overloads

Browse Source
This commit is contained in:
Christian Mazakas
2023-03-31 14:25:09 -07:00
parent cf39fc4c38
commit 52bf2bf7a2
2 changed files with 96 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
include/boost/unordered/concurrent_flat_map.hpp
View File

@ -18,6 +18,7 @@
#include <boost/unordered/detail/foa/concurrent_table.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/callable_traits/is_invocable.hpp>
#include <boost/container_hash/hash.hpp>
#include <boost/core/allocator_access.hpp>
#include <boost/type_traits/type_identity.hpp>
@ -25,6 +26,15 @@
#include <functional>
#include <utility>
#define BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F) \
static_assert(boost::callable_traits::is_invocable<F, value_type&>::value, \
"The provided Callable must be invocable with `value_type&`");
#define BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F) \
static_assert( \
boost::callable_traits::is_invocable<F, value_type const&>::value, \
"The provided Callable must be invocable with `value_type const&`");
namespace boost {
namespace unordered {
namespace detail {
@ -182,27 +192,32 @@ namespace boost {
template <class F> bool insert_or_visit(value_type const& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
return table_.insert_or_visit(obj, f);
}
template <class F> bool insert_or_visit(value_type&& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
return table_.insert_or_visit(std::move(obj), f);
}
template <class F> bool insert_or_visit(init_type const& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
return table_.insert_or_visit(obj, f);
}
template <class F> bool insert_or_visit(init_type&& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
return table_.insert_or_visit(std::move(obj), f);
}
template <class InputIterator, class F>
void insert_or_visit(InputIterator first, InputIterator last, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
for (; first != last; ++first) {
table_.insert_or_visit(*first, f);
}
@ -211,6 +226,47 @@ namespace boost {
template <class F>
void insert_or_visit(std::initializer_list<value_type> ilist, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
this->insert_or_visit(ilist.begin(), ilist.end(), f);
}
template <class F> bool insert_or_cvisit(value_type const& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
return table_.insert_or_cvisit(obj, f);
}
template <class F> bool insert_or_cvisit(value_type&& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
return table_.insert_or_cvisit(std::move(obj), f);
}
template <class F> bool insert_or_cvisit(init_type const& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
return table_.insert_or_cvisit(obj, f);
}
template <class F> bool insert_or_cvisit(init_type&& obj, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
return table_.insert_or_cvisit(std::move(obj), f);
}
template <class InputIterator, class F>
void insert_or_cvisit(InputIterator first, InputIterator last, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
for (; first != last; ++first) {
table_.insert_or_cvisit(*first, f);
}
}
template <class F>
void insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
{
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
this->insert_or_visit(ilist.begin(), ilist.end(), f);
}
@ -247,4 +303,7 @@ namespace boost {
} // namespace unordered
} // namespace boost
#undef BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE
#undef BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE
#endif // BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP

74
test/cfoa/insert_tests.cpp
View File

@ -225,7 +225,7 @@ namespace {
}
} trans_insert_or_assign_move_assign;
struct lvalue_insert_or_visit_const_visitor_type
struct lvalue_insert_or_cvisit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
@ -233,7 +233,7 @@ namespace {
std::atomic<std::uint64_t> num_invokes{0};
thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
for (auto& r : s) {
bool b = x.insert_or_visit(
bool b = x.insert_or_cvisit(
r, [&num_invokes](typename X::value_type const& v) {
(void)v;
++num_invokes;
@ -254,9 +254,9 @@ namespace {
BOOST_TEST_GT(raii::move_constructor, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u);
}
} lvalue_insert_or_visit_const_visitor;
} lvalue_insert_or_cvisit;
struct lvalue_insert_or_visit_mut_visitor_type
struct lvalue_insert_or_visit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
@ -285,9 +285,9 @@ namespace {
BOOST_TEST_GT(raii::move_constructor, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u);
}
} lvalue_insert_or_visit_mut_visitor;
} lvalue_insert_or_visit;
struct rvalue_insert_or_visit_const_visitor_type
struct rvalue_insert_or_cvisit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
@ -295,7 +295,7 @@ namespace {
std::atomic<std::uint64_t> num_invokes{0};
thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
for (auto& r : s) {
bool b = x.insert_or_visit(
bool b = x.insert_or_cvisit(
std::move(r), [&num_invokes](typename X::value_type const& v) {
(void)v;
++num_invokes;
@ -320,9 +320,9 @@ namespace {
BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
}
}
} rvalue_insert_or_visit_const_visitor;
} rvalue_insert_or_cvisit;
struct rvalue_insert_or_visit_mut_visitor_type
struct rvalue_insert_or_visit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
@ -354,9 +354,30 @@ namespace {
BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
}
}
} rvalue_insert_or_visit_mut_visitor;
} rvalue_insert_or_visit;
struct iterator_range_insert_or_visit_const_visitor_type
struct iterator_range_insert_or_cvisit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
std::atomic<std::uint64_t> num_invokes{0};
thread_runner(values, [&x, &num_invokes](boost::span<T> s) {
x.insert_or_cvisit(
s.begin(), s.end(), [&num_invokes](typename X::value_type const& v) {
(void)v;
++num_invokes;
});
});
BOOST_TEST_EQ(num_invokes, values.size() - x.size());
BOOST_TEST_EQ(raii::default_constructor, 0u);
BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
BOOST_TEST_GT(raii::move_constructor, 0u);
}
} iterator_range_insert_or_cvisit;
struct iterator_range_insert_or_visit_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
@ -375,28 +396,7 @@ namespace {
BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
BOOST_TEST_GT(raii::move_constructor, 0u);
}
} iterator_range_insert_or_visit_const_visitor;
struct iterator_range_insert_or_visit_mut_visitor_type
{
template <class T, class X> void operator()(std::vector<T>& values, X& x)
{
std::atomic<std::uint64_t> num_invokes{0};
thread_runner(values, [&x, &num_invokes](boost::span<T> s) {
x.insert_or_visit(
s.begin(), s.end(), [&num_invokes](typename X::value_type const& v) {
(void)v;
++num_invokes;
});
});
BOOST_TEST_EQ(num_invokes, values.size() - x.size());
BOOST_TEST_EQ(raii::default_constructor, 0u);
BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
BOOST_TEST_GT(raii::move_constructor, 0u);
}
} iterator_range_insert_or_visit_mut_visitor;
} iterator_range_insert_or_visit;
template <class X, class G, class F>
void insert(X*, G gen, F inserter, test::random_generator rg)
@ -507,7 +507,7 @@ namespace {
++num_invokes;
});
x.insert_or_visit(
x.insert_or_cvisit(
values, [&num_invokes](typename X::value_type const& v) {
(void)v;
++num_invokes;
@ -560,9 +560,9 @@ UNORDERED_TEST(
((value_type_generator)(init_type_generator))
((lvalue_inserter)(rvalue_inserter)(iterator_range_inserter)
(norehash_lvalue_inserter)(norehash_rvalue_inserter)
(lvalue_insert_or_visit_const_visitor)(lvalue_insert_or_visit_mut_visitor)
(rvalue_insert_or_visit_const_visitor)(rvalue_insert_or_visit_mut_visitor)
(iterator_range_insert_or_visit_const_visitor)(iterator_range_insert_or_visit_mut_visitor))
(lvalue_insert_or_cvisit)(lvalue_insert_or_visit)
(rvalue_insert_or_cvisit)(rvalue_insert_or_visit)
(iterator_range_insert_or_cvisit)(iterator_range_insert_or_visit))
((default_generator)(sequential)(limited_range)))
UNORDERED_TEST(