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

operator= noexcept support

Browse Source
This commit is contained in:
Daniel James
2018-01-05 17:54:44 +00:00
parent 5854090dc7
commit f12009fc61
4 changed files with 169 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3540,49 +3540,86 @@ namespace boost {
move_assign(x, is_unique,
boost::unordered::detail::integral_constant<bool,
allocator_traits<node_allocator>::
propagate_on_container_move_assignment::value>());
propagate_on_container_move_assignment::value>(),
boost::unordered::detail::integral_constant<bool,
functions::nothrow_move_assignable>());
}
}
// Propagate allocator, move assign functions throwable
template <typename UniqueType>
void move_assign(table& x, UniqueType, true_type)
void move_assign(table& x, UniqueType, true_type, false_type)
{
delete_buckets();
set_hash_functions new_func_this(*this, x);
// TODO: Can this throw? If so then breaks noexcept spec.
// Maybe don't do it if allocators are equal.
delete_buckets();
allocators_.move_assign(x.allocators_);
// No throw from here.
mlf_ = x.mlf_;
move_buckets_from(x);
new_func_this.commit();
}
// Propagate allocator, move assign functions noexcept
template <typename UniqueType>
void move_assign(table& x, UniqueType is_unique, false_type)
void move_assign(table& x, UniqueType, true_type, true_type)
{
delete_buckets();
allocators_.move_assign(x.allocators_);
mlf_ = x.mlf_;
move_buckets_from(x);
this->current_functions().move_assign(x.current_functions());
}
// Don't propagate allocator
template <typename UniqueType, typename IsNoExcept>
void move_assign(
table& x, UniqueType is_unique, false_type, IsNoExcept is_noexcept)
{
if (node_alloc() == x.node_alloc()) {
delete_buckets();
set_hash_functions new_func_this(*this, x);
// No throw from here.
mlf_ = x.mlf_;
move_buckets_from(x);
new_func_this.commit();
move_assign_equal_alloc(x, is_noexcept);
} else {
set_hash_functions new_func_this(*this, x);
mlf_ = x.mlf_;
recalculate_max_load();
if (x.size_ > max_load_) {
create_buckets(min_buckets_for_size(x.size_));
} else if (size_) {
clear_buckets();
}
new_func_this.commit();
move_assign_buckets(x, is_unique);
move_assign_realloc(x, is_unique);
}
}
// Move assign functions throwable
void move_assign_equal_alloc(table& x, false_type)
{
set_hash_functions new_func_this(*this, x);
delete_buckets();
mlf_ = x.mlf_;
move_buckets_from(x);
new_func_this.commit();
}
// Move assign functions noexcept
void move_assign_equal_alloc(table& x, true_type)
{
delete_buckets();
mlf_ = x.mlf_;
move_buckets_from(x);
this->current_functions().move_assign(x.current_functions());
}
template <typename UniqueType>
void move_assign_realloc(table& x, UniqueType is_unique)
{
set_hash_functions new_func_this(*this, x);
mlf_ = x.mlf_;
recalculate_max_load();
if (x.size_ > max_load_) {
create_buckets(min_buckets_for_size(x.size_));
} else if (size_) {
clear_buckets();
}
new_func_this.commit();
move_assign_buckets(x, is_unique);
}
// Accessors
const_key_type& get_key(node_pointer n) const

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

@ -151,10 +151,9 @@ namespace boost {
}
unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::true_type());
return *this;
@ -168,10 +167,9 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_map& operator=(unordered_map&& x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::true_type());
return *this;
@ -1023,10 +1021,9 @@ namespace boost {
}
unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::false_type());
return *this;
@ -1040,10 +1037,9 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multimap& operator=(unordered_multimap&& x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::false_type());
return *this;

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

@ -149,10 +149,9 @@ namespace boost {
}
unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::true_type());
return *this;
@ -166,10 +165,9 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_set& operator=(unordered_set&& x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::true_type());
return *this;
@ -706,10 +704,9 @@ namespace boost {
}
unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::false_type());
return *this;
@ -723,10 +720,9 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multiset& operator=(unordered_multiset&& x)
// C++17 support: BOOST_NOEXCEPT_IF(
// value_allocator_traits::is_always_equal::value &&
// is_nothrow_move_assignable_v<H> &&
// is_nothrow_move_assignable_v<P>)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
table_.move_assign(x.table_, boost::unordered::detail::false_type());
return *this;

113
test/unordered/noexcept_tests.cpp
View File

@ -18,11 +18,19 @@ namespace noexcept_tests {
struct hash_possible_exception : boost::hash<int>
{
hash_possible_exception(hash_possible_exception const&) {}
hash_possible_exception& operator=(hash_possible_exception const&)
{
return *this;
}
};
struct equal_to_possible_exception : std::equal_to<int>
{
equal_to_possible_exception(equal_to_possible_exception const&) {}
equal_to_possible_exception& operator=(equal_to_possible_exception const&)
{
return *this;
}
};
// Test that the move constructor does actually move without throwing
@ -88,7 +96,8 @@ namespace noexcept_tests {
}
};
typedef hash_nothrow<true, false, false> hash_nothrow_move;
typedef hash_nothrow<true, false, false> hash_nothrow_move_construct;
typedef hash_nothrow<false, true, false> hash_nothrow_move_assign;
typedef hash_nothrow<false, false, true> hash_nothrow_swap;
template <bool nothrow_move_construct, bool nothrow_move_assign,
@ -137,29 +146,40 @@ namespace noexcept_tests {
}
};
typedef equal_to_nothrow<true, false, false> equal_to_nothrow_move;
typedef equal_to_nothrow<true, false, false> equal_to_nothrow_move_construct;
typedef equal_to_nothrow<false, true, false> equal_to_nothrow_move_assign;
typedef equal_to_nothrow<false, false, true> equal_to_nothrow_swap;
bool have_is_nothrow_move = false;
bool have_is_nothrow_move_assign = false;
bool have_is_nothrow_swap = false;
UNORDERED_AUTO_TEST (check_is_nothrow_move) {
BOOST_TEST(
!boost::is_nothrow_move_constructible<hash_possible_exception>::value);
BOOST_TEST(
!boost::is_nothrow_move_assignable<hash_possible_exception>::value);
BOOST_TEST(!boost::unordered::detail::is_nothrow_swappable<
hash_possible_exception>::value);
BOOST_TEST((!boost::is_nothrow_move_constructible<
equal_to_nothrow<false, false, false> >::value));
BOOST_TEST((!boost::is_nothrow_move_assignable<
equal_to_nothrow<false, false, false> >::value));
BOOST_TEST((!boost::unordered::detail::is_nothrow_swappable<
equal_to_nothrow<false, false, false> >::value));
have_is_nothrow_move =
boost::is_nothrow_move_constructible<hash_nothrow_move>::value;
boost::is_nothrow_move_constructible<hash_nothrow_move_construct>::value;
have_is_nothrow_move_assign =
boost::is_nothrow_move_assignable<hash_nothrow_move_assign>::value;
have_is_nothrow_swap =
boost::unordered::detail::is_nothrow_swappable<hash_nothrow_swap>::value;
// Copied from boost::is_nothrow_move_constructible implementation
// to make sure this does actually detect it when expected.
//
// The type trait is also available when BOOST_IS_NOTHROW_MOVE_CONSTRUCT
// is defined (for some versions of Visual C++?) but detects 'throw()',
// not noexcept.
// Check that the traits work when expected.
#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && \
!BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
BOOST_TEST(have_is_nothrow_move);
BOOST_TEST(have_is_nothrow_move_assign);
#endif
#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) && \
@ -193,31 +213,66 @@ namespace noexcept_tests {
boost::hash<int>, equal_to_possible_exception> >::value));
}
UNORDERED_AUTO_TEST (test_no_throw_when_noexcept) {
typedef boost::unordered_set<int, hash_nothrow_move, equal_to_nothrow_move>
UNORDERED_AUTO_TEST (test_nothrow_move_when_noexcept) {
typedef boost::unordered_set<int, hash_nothrow_move_construct,
equal_to_nothrow_move_construct>
throwing_set;
if (have_is_nothrow_move) {
BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
throwing_test_exception = false;
throwing_set x1;
x1.insert(10);
x1.insert(50);
try {
throwing_test_exception = true;
throwing_set x2 = boost::move(x1);
BOOST_TEST(x2.size() == 2);
BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
} catch (test_exception) {
BOOST_TEST(false);
}
throwing_test_exception = false;
}
throwing_test_exception = false;
throwing_set x1;
x1.insert(10);
x1.insert(50);
try {
throwing_test_exception = true;
throwing_set x2 = boost::move(x1);
BOOST_TEST(x2.size() == 2);
BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
BOOST_TEST(have_is_nothrow_move);
} catch (test_exception) {
BOOST_TEST(!have_is_nothrow_move);
}
throwing_test_exception = false;
}
UNORDERED_AUTO_TEST (test_nothrow_move_assign_when_noexcept) {
typedef boost::unordered_set<int, hash_nothrow_move_assign,
equal_to_nothrow_move_assign>
throwing_set;
if (have_is_nothrow_move_assign) {
BOOST_TEST(boost::is_nothrow_move_assignable<throwing_set>::value);
}
throwing_test_exception = false;
throwing_set x1;
throwing_set x2;
x1.insert(10);
x1.insert(50);
for (int i = 0; i < 100; ++i) {
x2.insert(i);
}
try {
throwing_test_exception = true;
x2 = boost::move(x1);
BOOST_TEST(x2.size() == 2);
BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
BOOST_TEST(have_is_nothrow_move_assign);
} catch (test_exception) {
BOOST_TEST(!have_is_nothrow_move_assign);
}
throwing_test_exception = false;
}
UNORDERED_AUTO_TEST (test_nothrow_swap_when_noexcept) {