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

Use boost::is_nothrow_swappable, now that it's available everywhere

Browse Source
This commit is contained in:
Daniel James
2018-01-27 09:38:19 +00:00
parent c01a8c4629
commit 09be9bae04
5 changed files with 86 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -35,12 +35,11 @@
#include <boost/type_traits/integral_constant.hpp> #include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_base_of.hpp> #include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_class.hpp> #include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_empty.hpp> #include <boost/type_traits/is_empty.hpp>
#include <boost/type_traits/is_nothrow_move_assignable.hpp> #include <boost/type_traits/is_nothrow_move_assignable.hpp>
#include <boost/type_traits/is_nothrow_move_constructible.hpp> #include <boost/type_traits/is_nothrow_move_constructible.hpp>
#include <boost/type_traits/is_nothrow_swappable.hpp>
#include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_scalar.hpp>
#include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_const.hpp>
#include <boost/unordered/detail/fwd.hpp> #include <boost/unordered/detail/fwd.hpp>
#include <boost/utility/addressof.hpp> #include <boost/utility/addressof.hpp>
@ -740,19 +739,6 @@ namespace boost {
#pragma warning(pop) #pragma warning(pop)
#endif #endif
////////////////////////////////////////////////////////////////////////////
// is_nothrow_swappable
//
// TODO: Replace this very basic implementation when the full type_traits
// implementation is available.
template <class T>
struct is_nothrow_swappable
: boost::integral_constant<bool,
boost::is_scalar<T>::value && !boost::is_const<T>::value>
{
};
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// value_base // value_base
// //
@ -1800,7 +1786,7 @@ namespace boost {
BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2) BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
{ {
boost::unordered::detail::func::construct_from_tuple( boost::unordered::detail::func::construct_from_tuple(
alloc, boost::addressof (address->first), boost::forward<A1>(a1)); alloc, boost::addressof(address->first), boost::forward<A1>(a1));
BOOST_TRY BOOST_TRY
{ {
boost::unordered::detail::func::construct_from_tuple( boost::unordered::detail::func::construct_from_tuple(
@ -1997,7 +1983,7 @@ namespace boost {
{ {
BOOST_ASSERT(!node_); BOOST_ASSERT(!node_);
node_ = node_allocator_traits::allocate(alloc_, 1); node_ = node_allocator_traits::allocate(alloc_, 1);
new ((void*) boost::to_address(node_)) node(); new ((void*)boost::to_address(node_)) node();
} }
template <typename NodeAlloc> struct node_tmp template <typename NodeAlloc> struct node_tmp
@ -2756,8 +2742,8 @@ namespace boost {
boost::is_nothrow_move_constructible<H>::value && boost::is_nothrow_move_constructible<H>::value &&
boost::is_nothrow_move_constructible<P>::value; boost::is_nothrow_move_constructible<P>::value;
static const bool nothrow_swappable = static const bool nothrow_swappable =
boost::unordered::detail::is_nothrow_swappable<H>::value && boost::is_nothrow_swappable<H>::value &&
boost::unordered::detail::is_nothrow_swappable<P>::value; boost::is_nothrow_swappable<P>::value;
private: private:
functions& operator=(functions const&); functions& operator=(functions const&);
@ -3220,9 +3206,9 @@ namespace boost {
bucket_pointer end = bucket_pointer end =
buckets_ + static_cast<std::ptrdiff_t>(new_count); buckets_ + static_cast<std::ptrdiff_t>(new_count);
for (bucket_pointer i = buckets_; i != end; ++i) { for (bucket_pointer i = buckets_; i != end; ++i) {
new ((void*) boost::to_address(i)) bucket(); new ((void*)boost::to_address(i)) bucket();
} }
new ((void*) boost::to_address(end)) bucket(dummy_node); new ((void*)boost::to_address(end)) bucket(dummy_node);
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////

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

@ -717,8 +717,8 @@ namespace boost {
void swap(unordered_map&) void swap(unordered_map&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value); boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); } void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2> template <typename H2, typename P2>
@ -1326,8 +1326,8 @@ namespace boost {
void swap(unordered_multimap&) void swap(unordered_multimap&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value); boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); } void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2> template <typename H2, typename P2>
@ -1737,8 +1737,8 @@ namespace boost {
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
void unordered_map<K, T, H, P, A>::swap(unordered_map& other) void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value) boost::is_nothrow_swappable<P>::value)
{ {
table_.swap(other.table_); table_.swap(other.table_);
} }
@ -2213,8 +2213,8 @@ namespace boost {
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other) void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value) boost::is_nothrow_swappable<P>::value)
{ {
table_.swap(other.table_); table_.swap(other.table_);
} }

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

@ -443,8 +443,8 @@ namespace boost {
void swap(unordered_set&) void swap(unordered_set&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value); boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); } void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2> template <typename H2, typename P2>
@ -990,8 +990,8 @@ namespace boost {
void swap(unordered_multiset&) void swap(unordered_multiset&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value); boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); } void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2> template <typename H2, typename P2>
@ -1362,8 +1362,8 @@ namespace boost {
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
void unordered_set<T, H, P, A>::swap(unordered_set& other) void unordered_set<T, H, P, A>::swap(unordered_set& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value) boost::is_nothrow_swappable<P>::value)
{ {
table_.swap(other.table_); table_.swap(other.table_);
} }
@ -1756,8 +1756,8 @@ namespace boost {
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other) void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&& BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&& boost::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value) boost::is_nothrow_swappable<P>::value)
{ {
table_.swap(other.table_); table_.swap(other.table_);
} }

93
test/unordered/compile_tests.hpp
View File

@ -17,11 +17,12 @@
#endif #endif
#include "../helpers/check_return_type.hpp" #include "../helpers/check_return_type.hpp"
#include <boost/limits.hpp>
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/limits.hpp>
#include <boost/predef.h> #include <boost/predef.h>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <boost/type_traits/cv_traits.hpp> #include <boost/type_traits/cv_traits.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_convertible.hpp> #include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_same.hpp>
#include <boost/utility/swap.hpp> #include <boost/utility/swap.hpp>
@ -286,36 +287,47 @@ template <class X, class Key> void unordered_set_test(X& r, Key const&)
BOOST_STATIC_ASSERT((boost::is_same<iterator, BOOST_STATIC_ASSERT((boost::is_same<iterator,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value)); BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, boost::pointer_traits<iterator>::element_type>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::difference_type>::value)); BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
iterator>::difference_type>::value));
// pointer_traits<const_iterator> // pointer_traits<const_iterator>
BOOST_STATIC_ASSERT((boost::is_same<const_iterator, BOOST_STATIC_ASSERT((
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::pointer>::value)); boost::is_same<const_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
const_iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, boost::pointer_traits<const_iterator>::element_type>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::difference_type>::value)); BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
const_iterator>::difference_type>::value));
// pointer_traits<local_iterator> // pointer_traits<local_iterator>
BOOST_STATIC_ASSERT((boost::is_same<local_iterator, BOOST_STATIC_ASSERT((
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::pointer>::value)); boost::is_same<local_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
local_iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, boost::pointer_traits<local_iterator>::element_type>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::difference_type>::value)); BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
local_iterator>::difference_type>::value));
// pointer_traits<const_local_iterator> // pointer_traits<const_local_iterator>
BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator, BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::pointer>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::element_type>::value));
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::difference_type>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::difference_type>::value));
typedef BOOST_DEDUCED_TYPENAME X::node_type node_type; typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type; typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
@ -366,37 +378,48 @@ void unordered_map_test(X& r, Key const& k, T const& v)
BOOST_STATIC_ASSERT((boost::is_same<iterator, BOOST_STATIC_ASSERT((boost::is_same<iterator,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value)); BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type, BOOST_STATIC_ASSERT(
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::element_type>::value)); (boost::is_same<value_type, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, iterator>::element_type>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::difference_type>::value)); BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
iterator>::difference_type>::value));
// pointer_traits<const_iterator> // pointer_traits<const_iterator>
BOOST_STATIC_ASSERT((boost::is_same<const_iterator, BOOST_STATIC_ASSERT((
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::pointer>::value)); boost::is_same<const_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
const_iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, boost::pointer_traits<const_iterator>::element_type>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::difference_type>::value)); BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
const_iterator>::difference_type>::value));
// pointer_traits<local_iterator> // pointer_traits<local_iterator>
BOOST_STATIC_ASSERT((boost::is_same<local_iterator, BOOST_STATIC_ASSERT((
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::pointer>::value)); boost::is_same<local_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
BOOST_STATIC_ASSERT((boost::is_same<value_type, local_iterator>::pointer>::value));
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::element_type>::value)); BOOST_STATIC_ASSERT(
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, (boost::is_same<value_type, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::difference_type>::value)); local_iterator>::element_type>::value));
BOOST_STATIC_ASSERT((
boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
local_iterator>::difference_type>::value));
// pointer_traits<const_local_iterator> // pointer_traits<const_local_iterator>
BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator, BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::pointer>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::pointer>::value));
BOOST_STATIC_ASSERT((boost::is_same<value_type const, BOOST_STATIC_ASSERT((boost::is_same<value_type const,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::element_type>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::element_type>::value));
BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t, BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::difference_type>::value)); BOOST_DEDUCED_TYPENAME
boost::pointer_traits<const_local_iterator>::difference_type>::value));
typedef BOOST_DEDUCED_TYPENAME X::node_type node_type; typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type; typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;

13
test/unordered/noexcept_tests.cpp
View File

@ -165,13 +165,12 @@ namespace noexcept_tests {
!boost::is_nothrow_move_constructible<hash_possible_exception>::value); !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
BOOST_TEST( BOOST_TEST(
!boost::is_nothrow_move_assignable<hash_possible_exception>::value); !boost::is_nothrow_move_assignable<hash_possible_exception>::value);
BOOST_TEST(!boost::unordered::detail::is_nothrow_swappable< BOOST_TEST(!boost::is_nothrow_swappable<hash_possible_exception>::value);
hash_possible_exception>::value);
BOOST_TEST((!boost::is_nothrow_move_constructible< BOOST_TEST((!boost::is_nothrow_move_constructible<
equal_to_nothrow<false, false, false> >::value)); equal_to_nothrow<false, false, false> >::value));
BOOST_TEST((!boost::is_nothrow_move_assignable< BOOST_TEST((!boost::is_nothrow_move_assignable<
equal_to_nothrow<false, false, false> >::value)); equal_to_nothrow<false, false, false> >::value));
BOOST_TEST((!boost::unordered::detail::is_nothrow_swappable< BOOST_TEST((!boost::is_nothrow_swappable<
equal_to_nothrow<false, false, false> >::value)); equal_to_nothrow<false, false, false> >::value));
have_is_nothrow_move = have_is_nothrow_move =
@ -179,7 +178,7 @@ namespace noexcept_tests {
have_is_nothrow_move_assign = have_is_nothrow_move_assign =
boost::is_nothrow_move_assignable<hash_nothrow_move_assign>::value; boost::is_nothrow_move_assignable<hash_nothrow_move_assign>::value;
have_is_nothrow_swap = have_is_nothrow_swap =
boost::unordered::detail::is_nothrow_swappable<hash_nothrow_swap>::value; boost::is_nothrow_swappable<hash_nothrow_swap>::value;
// Check that the traits work when expected. // Check that the traits work when expected.
#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && \ #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && \
@ -191,8 +190,7 @@ namespace noexcept_tests {
#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) && \ #if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) && \
!defined(BOOST_NO_CXX11_DECLTYPE) && \ !defined(BOOST_NO_CXX11_DECLTYPE) && \
!defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
// TODO: Turn test on when unordered starts to use is_nothrow_swap BOOST_TEST(have_is_nothrow_swap);
// BOOST_TEST(have_is_nothrow_swap);
#endif #endif
BOOST_LIGHTWEIGHT_TEST_OSTREAM BOOST_LIGHTWEIGHT_TEST_OSTREAM
@ -286,8 +284,7 @@ namespace noexcept_tests {
throwing_set; throwing_set;
if (have_is_nothrow_swap) { if (have_is_nothrow_swap) {
BOOST_TEST( BOOST_TEST(boost::is_nothrow_swappable<throwing_set>::value);
boost::unordered::detail::is_nothrow_swappable<throwing_set>::value);
} }
throwing_test_exception = false; throwing_test_exception = false;