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

Resolve potential ambiguities during insertion by introducing a member function template

Browse Source
This commit is contained in:
Christian Mazakas
2023-06-01 14:19:14 -07:00
parent e7c1e1a56e
commit 44c50cd2ea
2 changed files with 24 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -409,19 +409,13 @@ namespace boost {
/// Modifiers /// Modifiers
/// ///
BOOST_FORCEINLINE bool insert(value_type const& obj) template <class Ty>
BOOST_FORCEINLINE auto insert(Ty&& value)
-> decltype(table_.insert(std::forward<Ty>(value)))
{ {
return table_.insert(obj); return table_.insert(std::forward<Ty>(value));
}
BOOST_FORCEINLINE bool insert(value_type&& obj)
{
return table_.insert(std::move(obj));
} }
BOOST_FORCEINLINE bool insert(init_type const& obj)
{
return table_.insert(obj);
}
BOOST_FORCEINLINE bool insert(init_type&& obj) BOOST_FORCEINLINE bool insert(init_type&& obj)
{ {
return table_.insert(std::move(obj)); return table_.insert(std::move(obj));
@ -464,25 +458,11 @@ namespace boost {
[&](value_type& m) { m.second = std::forward<M>(obj); }); [&](value_type& m) { m.second = std::forward<M>(obj); });
} }
template <class F> template <class Ty, class F>
BOOST_FORCEINLINE bool insert_or_visit(value_type const& obj, F f) BOOST_FORCEINLINE auto insert_or_visit(Ty&& value, F f)
-> decltype(table_.insert_or_visit(std::forward<Ty>(value), f))
{ {
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F) return table_.insert_or_visit(std::forward<Ty>(value), f);
return table_.insert_or_visit(obj, f);
}
template <class F>
BOOST_FORCEINLINE 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>
BOOST_FORCEINLINE 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> template <class F>
@ -508,25 +488,12 @@ namespace boost {
this->insert_or_visit(ilist.begin(), ilist.end(), f); this->insert_or_visit(ilist.begin(), ilist.end(), f);
} }
template <class F> template <class Ty, class F>
BOOST_FORCEINLINE bool insert_or_cvisit(value_type const& obj, F f) BOOST_FORCEINLINE auto insert_or_cvisit(Ty&& value, F f)
-> decltype(table_.insert_or_cvisit(std::forward<Ty>(value), f))
{ {
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F) BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
return table_.insert_or_cvisit(obj, f); return table_.insert_or_cvisit(std::forward<Ty>(value), f);
}
template <class F>
BOOST_FORCEINLINE 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>
BOOST_FORCEINLINE 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> template <class F>

12
test/cfoa/insert_tests.cpp
View File

@ -540,6 +540,18 @@ namespace {
} }
} }
UNORDERED_AUTO_TEST (insert_sfinae_test) {
// mostly a compile-time tests to ensure that there's no ambiguity when a
// user does this
using value_type =
typename boost::unordered::concurrent_flat_map<raii, raii>::value_type;
boost::unordered::concurrent_flat_map<raii, raii> x;
x.insert({1, 2});
x.insert_or_visit({2, 3}, [](value_type&) {});
x.insert_or_cvisit({3, 4}, [](value_type const&) {});
}
boost::unordered::concurrent_flat_map<raii, raii>* map; boost::unordered::concurrent_flat_map<raii, raii>* map;
boost::unordered::concurrent_flat_map<raii, raii, transp_hash, boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
transp_key_equal>* trans_map; transp_key_equal>* trans_map;