feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests 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/is_base_of.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_nothrow_move_assignable.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_scalar.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/unordered/detail/fwd.hpp>
#include <boost/utility/addressof.hpp>
@@ -740,19 +739,6 @@ namespace boost {
#pragma warning(pop)
#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
//
@@ -1800,7 +1786,7 @@ namespace boost {
BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
{
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::unordered::detail::func::construct_from_tuple(
@@ -1997,7 +1983,7 @@ namespace boost {
{
BOOST_ASSERT(!node_);
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
@@ -2756,8 +2742,8 @@ namespace boost {
boost::is_nothrow_move_constructible<H>::value &&
boost::is_nothrow_move_constructible<P>::value;
static const bool nothrow_swappable =
boost::unordered::detail::is_nothrow_swappable<H>::value &&
boost::unordered::detail::is_nothrow_swappable<P>::value;
boost::is_nothrow_swappable<H>::value &&
boost::is_nothrow_swappable<P>::value;
private:
functions& operator=(functions const&);
@@ -3220,9 +3206,9 @@ namespace boost {
bucket_pointer end =
buckets_ + static_cast<std::ptrdiff_t>(new_count);
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&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value);
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2>
@@ -1326,8 +1326,8 @@ namespace boost {
void swap(unordered_multimap&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value);
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
template <typename H2, typename P2>
@@ -1737,8 +1737,8 @@ namespace boost {
template <class K, class T, class H, class P, class A>
void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value)
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
table_.swap(other.table_);
}
@@ -2213,8 +2213,8 @@ namespace boost {
template <class K, class T, class H, class P, class A>
void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
boost::unordered::detail::is_nothrow_swappable<H>::value&&
boost::unordered::detail::is_nothrow_swappable<P>::value)
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
table_.swap(other.table_);
}

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

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