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

Remove BOOST_NOEXCEPT

Browse Source
This commit is contained in:
Christian Mazakas
2023-08-28 12:24:25 -07:00
parent 6b65c8f230
commit aa16d1b8a9
10 changed files with 427 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
include/boost/unordered/detail/fca.hpp
View File

@ -147,14 +147,14 @@ namespace boost {
typename boost::aligned_storage<sizeof(value_type),
boost::alignment_of<value_type>::value>::type buf;
node() BOOST_NOEXCEPT : next(), buf() {}
node() noexcept : next(), buf() {}
value_type* value_ptr() BOOST_NOEXCEPT
value_type* value_ptr() noexcept
{
return reinterpret_cast<value_type*>(buf.address());
}
value_type& value() BOOST_NOEXCEPT
value_type& value() noexcept
{
return *reinterpret_cast<value_type*>(buf.address());
}
@ -170,7 +170,7 @@ namespace boost {
node_pointer next;
bucket() BOOST_NOEXCEPT : next() {}
bucket() noexcept : next() {}
};
template <class Bucket> struct bucket_group
@ -186,7 +186,7 @@ namespace boost {
std::size_t bitmask;
bucket_group_pointer next, prev;
bucket_group() BOOST_NOEXCEPT : buckets(), bitmask(0), next(), prev() {}
bucket_group() noexcept : buckets(), bitmask(0), next(), prev() {}
~bucket_group() {}
};
@ -224,33 +224,28 @@ namespace boost {
public:
grouped_bucket_iterator() : p(), pbg() {}
reference operator*() const BOOST_NOEXCEPT { return dereference(); }
pointer operator->() const BOOST_NOEXCEPT
{
return boost::to_address(p);
}
reference operator*() const noexcept { return dereference(); }
pointer operator->() const noexcept { return boost::to_address(p); }
grouped_bucket_iterator& operator++() BOOST_NOEXCEPT
grouped_bucket_iterator& operator++() noexcept
{
increment();
return *this;
}
grouped_bucket_iterator operator++(int) BOOST_NOEXCEPT
grouped_bucket_iterator operator++(int) noexcept
{
grouped_bucket_iterator old = *this;
increment();
return old;
}
bool operator==(
grouped_bucket_iterator const& other) const BOOST_NOEXCEPT
bool operator==(grouped_bucket_iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(
grouped_bucket_iterator const& other) const BOOST_NOEXCEPT
bool operator!=(grouped_bucket_iterator const& other) const noexcept
{
return !equal(other);
}
@ -266,14 +261,14 @@ namespace boost {
{
}
Bucket& dereference() const BOOST_NOEXCEPT { return *p; }
Bucket& dereference() const noexcept { return *p; }
bool equal(const grouped_bucket_iterator& x) const BOOST_NOEXCEPT
bool equal(const grouped_bucket_iterator& x) const noexcept
{
return p == x.p;
}
void increment() BOOST_NOEXCEPT
void increment() noexcept
{
std::size_t const offset = static_cast<std::size_t>(p - pbg->buckets);
@ -290,7 +285,7 @@ namespace boost {
}
}
template<typename Archive>
template <typename Archive>
friend void serialization_track(
Archive& ar, grouped_bucket_iterator const& x)
{
@ -301,8 +296,7 @@ namespace boost {
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive& ar,unsigned int)
template <typename Archive> void serialize(Archive& ar, unsigned int)
{
// requires: not at end() position
serialize_tracked_address(ar, p);
@ -326,20 +320,17 @@ namespace boost {
grouped_local_bucket_iterator() : p() {}
reference operator*() const BOOST_NOEXCEPT { return dereference(); }
reference operator*() const noexcept { return dereference(); }
pointer operator->() const BOOST_NOEXCEPT
{
return boost::to_address(p);
}
pointer operator->() const noexcept { return boost::to_address(p); }
grouped_local_bucket_iterator& operator++() BOOST_NOEXCEPT
grouped_local_bucket_iterator& operator++() noexcept
{
increment();
return *this;
}
grouped_local_bucket_iterator operator++(int) BOOST_NOEXCEPT
grouped_local_bucket_iterator operator++(int) noexcept
{
grouped_local_bucket_iterator old = *this;
increment();
@ -347,13 +338,13 @@ namespace boost {
}
bool operator==(
grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
grouped_local_bucket_iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(
grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
grouped_local_bucket_iterator const& other) const noexcept
{
return !equal(other);
}
@ -366,14 +357,14 @@ namespace boost {
grouped_local_bucket_iterator(node_pointer p_) : p(p_) {}
value_type& dereference() const BOOST_NOEXCEPT { return p->value(); }
value_type& dereference() const noexcept { return p->value(); }
bool equal(const grouped_local_bucket_iterator& x) const BOOST_NOEXCEPT
bool equal(const grouped_local_bucket_iterator& x) const noexcept
{
return p == x.p;
}
void increment() BOOST_NOEXCEPT { p = p->next; }
void increment() noexcept { p = p->next; }
node_pointer p;
};
@ -397,20 +388,17 @@ namespace boost {
{
}
reference operator*() const BOOST_NOEXCEPT { return dereference(); }
reference operator*() const noexcept { return dereference(); }
pointer operator->() const BOOST_NOEXCEPT
{
return boost::to_address(p);
}
pointer operator->() const noexcept { return boost::to_address(p); }
const_grouped_local_bucket_iterator& operator++() BOOST_NOEXCEPT
const_grouped_local_bucket_iterator& operator++() noexcept
{
increment();
return *this;
}
const_grouped_local_bucket_iterator operator++(int) BOOST_NOEXCEPT
const_grouped_local_bucket_iterator operator++(int) noexcept
{
const_grouped_local_bucket_iterator old = *this;
increment();
@ -418,13 +406,13 @@ namespace boost {
}
bool operator==(
const_grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
const_grouped_local_bucket_iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(
const_grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
const_grouped_local_bucket_iterator const& other) const noexcept
{
return !equal(other);
}
@ -435,23 +423,22 @@ namespace boost {
const_grouped_local_bucket_iterator(node_pointer p_) : p(p_) {}
value_type& dereference() const BOOST_NOEXCEPT { return p->value(); }
value_type& dereference() const noexcept { return p->value(); }
bool equal(
const const_grouped_local_bucket_iterator& x) const BOOST_NOEXCEPT
bool equal(const const_grouped_local_bucket_iterator& x) const noexcept
{
return p == x.p;
}
void increment() BOOST_NOEXCEPT { p = p->next; }
void increment() noexcept { p = p->next; }
node_pointer p;
};
template <class T> struct span
{
T* begin() const BOOST_NOEXCEPT { return data; }
T* end() const BOOST_NOEXCEPT { return data + size; }
T* begin() const noexcept { return data; }
T* end() const noexcept { return data + size; }
T* data;
std::size_t size;
@ -532,8 +519,7 @@ namespace boost {
grouped_bucket_array(size_type n, const Allocator& al)
: empty_value<node_allocator_type>(empty_init_t(), al),
size_index_(0),
size_(0), buckets(), groups()
size_index_(0), size_(0), buckets(), groups()
{
if (n == 0) {
return;
@ -582,8 +568,7 @@ namespace boost {
~grouped_bucket_array() { this->deallocate(); }
grouped_bucket_array(
BOOST_RV_REF(grouped_bucket_array) other) BOOST_NOEXCEPT
grouped_bucket_array(BOOST_RV_REF(grouped_bucket_array) other) noexcept
: empty_value<node_allocator_type>(
empty_init_t(), other.get_node_allocator()),
size_index_(other.size_index_),
@ -598,7 +583,7 @@ namespace boost {
}
grouped_bucket_array& operator=(
BOOST_RV_REF(grouped_bucket_array) other) BOOST_NOEXCEPT
BOOST_RV_REF(grouped_bucket_array) other) noexcept
{
BOOST_ASSERT(
this->get_node_allocator() == other.get_node_allocator());
@ -622,7 +607,7 @@ namespace boost {
return *this;
}
void deallocate() BOOST_NOEXCEPT
void deallocate() noexcept
{
if (buckets) {
bucket_allocator_type bucket_alloc = this->get_bucket_allocator();
@ -651,7 +636,8 @@ namespace boost {
bool b = boost::allocator_propagate_on_container_swap<
allocator_type>::type::value;
if (b) {
boost::core::invoke_swap(get_node_allocator(), other.get_node_allocator());
boost::core::invoke_swap(
get_node_allocator(), other.get_node_allocator());
}
}
@ -675,12 +661,9 @@ namespace boost {
return this->get_node_allocator();
}
size_type buckets_len() const BOOST_NOEXCEPT { return size_ + 1; }
size_type buckets_len() const noexcept { return size_ + 1; }
size_type groups_len() const BOOST_NOEXCEPT
{
return size_ / group::N + 1;
}
size_type groups_len() const noexcept { return size_ / group::N + 1; }
void reset_allocator(Allocator const& allocator_)
{
@ -713,7 +696,7 @@ namespace boost {
local_iterator end(size_type) const { return local_iterator(); }
size_type capacity() const BOOST_NOEXCEPT { return size_; }
size_type capacity() const noexcept { return size_; }
iterator at(size_type n) const
{
@ -747,7 +730,7 @@ namespace boost {
size_ = 0;
}
void append_bucket_group(iterator itb) BOOST_NOEXCEPT
void append_bucket_group(iterator itb) noexcept
{
std::size_t const N = group::N;
@ -777,7 +760,7 @@ namespace boost {
}
}
void insert_node(iterator itb, node_pointer p) BOOST_NOEXCEPT
void insert_node(iterator itb, node_pointer p) noexcept
{
this->append_bucket_group(itb);
@ -786,7 +769,7 @@ namespace boost {
}
void insert_node_hint(
iterator itb, node_pointer p, node_pointer hint) BOOST_NOEXCEPT
iterator itb, node_pointer p, node_pointer hint) noexcept
{
this->append_bucket_group(itb);
@ -799,7 +782,7 @@ namespace boost {
}
}
void extract_node(iterator itb, node_pointer p) BOOST_NOEXCEPT
void extract_node(iterator itb, node_pointer p) noexcept
{
node_pointer* pp = boost::addressof(itb->next);
while ((*pp) != p)
@ -809,14 +792,14 @@ namespace boost {
unlink_bucket(itb);
}
void extract_node_after(iterator itb, node_pointer* pp) BOOST_NOEXCEPT
void extract_node_after(iterator itb, node_pointer* pp) noexcept
{
*pp = (*pp)->next;
if (!itb->next)
unlink_bucket(itb);
}
void unlink_empty_buckets() BOOST_NOEXCEPT
void unlink_empty_buckets() noexcept
{
std::size_t const N = group::N;
@ -864,7 +847,7 @@ namespace boost {
}
};
} // namespace detail
} // namespace unordered
} // namespace unordered
} // namespace boost
#endif // BOOST_UNORDERED_DETAIL_FCA_HPP

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

@ -1,7 +1,7 @@
// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
// Copyright (C) 2005-2016 Daniel James
// Copyright (C) 2022-2023 Joaquin M Lopez Munoz.
// Copyright (C) 2022 Christian Mazakas
// Copyright (C) 2022-2023 Christian Mazakas
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -14,6 +14,11 @@
#pragma once
#endif
#include <boost/unordered/detail/fca.hpp>
#include <boost/unordered/detail/fwd.hpp>
#include <boost/unordered/detail/serialize_tracked_address.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/assert.hpp>
#include <boost/core/allocator_traits.hpp>
#include <boost/core/bit.hpp>
@ -47,12 +52,9 @@
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/make_void.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/unordered/detail/fca.hpp>
#include <boost/unordered/detail/serialize_tracked_address.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/unordered/detail/fwd.hpp>
#include <boost/utility/addressof.hpp>
#include <boost/utility/enable_if.hpp>
#include <cmath>
#include <iterator>
#include <stdexcept>
@ -63,8 +65,8 @@
#endif
#if BOOST_UNORDERED_CXX11_CONSTRUCTION
#include <boost/mp11/list.hpp>
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#endif
// BOOST_UNORDERED_SUPPRESS_DEPRECATED
@ -125,7 +127,7 @@ namespace boost {
template <class T> inline void ignore_unused_variable_warning(T const&)
{
}
}
} // namespace func
//////////////////////////////////////////////////////////////////////////
// iterator SFINAE
@ -138,20 +140,20 @@ namespace boost {
template <typename I, typename ReturnType>
struct enable_if_forward
: boost::enable_if_c<boost::unordered::detail::is_forward<I>::value,
ReturnType>
: boost::enable_if_c<boost::unordered::detail::is_forward<I>::value,
ReturnType>
{
};
template <typename I, typename ReturnType>
struct disable_if_forward
: boost::disable_if_c<boost::unordered::detail::is_forward<I>::value,
ReturnType>
: boost::disable_if_c<boost::unordered::detail::is_forward<I>::value,
ReturnType>
{
};
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
@ -169,7 +171,8 @@ namespace boost {
template <class I>
inline typename boost::unordered::detail::disable_if_forward<I,
std::size_t>::type insert_size(I, I)
std::size_t>::type
insert_size(I, I)
{
return 1;
}
@ -211,8 +214,8 @@ namespace boost {
template <typename T1, typename T2>
struct compressed
: private boost::unordered::detail::generate_base<T1, 1>::type,
private boost::unordered::detail::generate_base<T2, 2>::type
: private boost::unordered::detail::generate_base<T1, 1>::type,
private boost::unordered::detail::generate_base<T2, 2>::type
{
typedef typename generate_base<T1, 1>::type base1;
typedef typename generate_base<T2, 2>::type base2;
@ -353,9 +356,9 @@ namespace boost {
{
template <typename T> convert_from_anything(T const&);
};
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
////////////////////////////////////////////////////////////////////////////
// emplace_args
@ -412,7 +415,7 @@ namespace boost {
\
template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
inline BOOST_PP_CAT(emplace_args, n)<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> \
create_emplace_args(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b)) \
create_emplace_args(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b)) \
{ \
BOOST_PP_CAT(emplace_args, n)<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> e( \
BOOST_PP_ENUM_PARAMS_Z(z, n, b)); \
@ -477,9 +480,9 @@ namespace boost {
BOOST_UNORDERED_EARGS(1, 9, _)
BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
BOOST_UNORDERED_EARGS, _)
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
#undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
#undef BOOST_UNORDERED_EARGS_MEMBER
@ -496,16 +499,16 @@ namespace boost {
namespace unordered {
namespace detail {
////////////////////////////////////////////////////////////////////////////
// Integral_constrant, true_type, false_type
//
// Uses the standard versions if available.
////////////////////////////////////////////////////////////////////////////
// Integral_constrant, true_type, false_type
//
// Uses the standard versions if available.
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
using std::false_type;
using std::integral_constant;
using std::true_type;
using std::false_type;
#else
@ -523,8 +526,8 @@ namespace boost {
#endif
////////////////////////////////////////////////////////////////////////////
// Explicitly call a destructor
////////////////////////////////////////////////////////////////////////////
// Explicitly call a destructor
#if defined(BOOST_MSVC)
#pragma warning(push)
@ -533,7 +536,7 @@ namespace boost {
namespace func {
template <class T> inline void destroy(T* x) { x->~T(); }
}
} // namespace func
#if defined(BOOST_MSVC)
#pragma warning(pop)
@ -596,7 +599,7 @@ namespace boost {
}
public:
optional() BOOST_NOEXCEPT : has_value_(false) {}
optional() noexcept : has_value_(false) {}
optional(BOOST_RV_REF(optional<T>) x) : has_value_(false)
{
@ -650,9 +653,9 @@ namespace boost {
friend void swap(optional<T>& x, optional<T>& y) { x.swap(y); }
};
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
////////////////////////////////////////////////////////////////////////////////
//
@ -672,9 +675,9 @@ namespace boost {
struct rebind_wrap : boost::allocator_rebind<Alloc, T>
{
};
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
////////////////////////////////////////////////////////////////////////////
// Functions used to construct nodes. Emulates variadic construction,
@ -699,10 +702,10 @@ namespace boost {
{
new ((void*)address) T(boost::forward<Args>(args)...);
}
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#else
@ -720,10 +723,10 @@ namespace boost {
{
new ((void*)address) T(boost::forward<A0>(a0));
}
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#endif
@ -769,10 +772,10 @@ namespace boost {
BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 8, boost)
BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 9, boost)
BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#endif
@ -800,10 +803,10 @@ namespace boost {
BOOST_PP_REPEAT_FROM_TO(6, BOOST_PP_INC(BOOST_UNORDERED_TUPLE_ARGS),
BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE, std)
#endif
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#endif
@ -866,10 +869,10 @@ namespace boost {
boost::tuples::length<Tuple>::value>(),
alloc, ptr, x);
}
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
#undef BOOST_UNORDERED_GET_TUPLE_ARG
@ -937,7 +940,7 @@ namespace boost {
to_std_tuple_impl(boost::mp11::mp_list<Args...>,
boost::tuple<TupleArgs...>& tuple, boost::mp11::index_sequence<Is...>)
{
(void) tuple;
(void)tuple;
return std::tuple<typename std::add_lvalue_reference<Args>::type...>(
boost::get<Is>(tuple)...);
}
@ -1041,7 +1044,7 @@ namespace boost {
boost::forward<A1>(args.a1), boost::forward<A2>(args.a2));
}
// Use a macro for the rest.
// Use a macro for the rest.
#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
template <typename Alloc, typename T, \
@ -1090,10 +1093,10 @@ namespace boost {
}
#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
}
}
}
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
@ -1182,9 +1185,9 @@ namespace boost {
boost::allocator_deallocate(alloc_, node_, 1);
}
}
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
@ -1247,8 +1250,8 @@ namespace boost {
value_allocator val_alloc(alloc);
boost::allocator_construct(
val_alloc, a.node_->value_ptr(), std::piecewise_construct,
boost::allocator_construct(val_alloc, a.node_->value_ptr(),
std::piecewise_construct,
std::forward_as_tuple(boost::forward<Key>(k)),
std::forward_as_tuple());
return a.release();
@ -1409,9 +1412,9 @@ namespace boost {
return construct_node_pair(alloc, boost::forward<Key>(k));
}
} // namespace func
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
#if defined(BOOST_MSVC)
#pragma warning(pop)
@ -1437,12 +1440,12 @@ namespace boost {
// in that region of storage. This warning is also generated in C++03
// which does not have `std::launder`. The compiler builtin is always
// available, regardless of the C++ standard used when compiling.
template <class T> T* launder(T* p) BOOST_NOEXCEPT
template <class T> T* launder(T* p) noexcept
{
return __builtin_launder(p);
}
#else
template <class T> T* launder(T* p) BOOST_NOEXCEPT { return p; }
template <class T> T* launder(T* p) noexcept { return p; }
#endif
template <class H, class P> class functions
@ -1566,9 +1569,9 @@ namespace boost {
}
};
////////////////////////////////////////////////////////////////////////////
// rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
// e.g. for int
////////////////////////////////////////////////////////////////////////////
// rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
// e.g. for int
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
@ -1626,48 +1629,48 @@ namespace boost {
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
iterator() : p(), itb(){}
iterator() : p(), itb() {}
reference operator*() const BOOST_NOEXCEPT { return dereference(); }
pointer operator->() const BOOST_NOEXCEPT
reference operator*() const noexcept { return dereference(); }
pointer operator->() const noexcept
{
pointer x = boost::addressof(p->value());
return x;
}
iterator& operator++() BOOST_NOEXCEPT
iterator& operator++() noexcept
{
increment();
return *this;
}
iterator operator++(int) BOOST_NOEXCEPT
iterator operator++(int) noexcept
{
iterator old = *this;
increment();
return old;
}
bool operator==(iterator const& other) const BOOST_NOEXCEPT
bool operator==(iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(iterator const& other) const BOOST_NOEXCEPT
bool operator!=(iterator const& other) const noexcept
{
return !equal(other);
}
bool operator==(
boost::unordered::detail::iterator_detail::c_iterator<Node,
Bucket> const& other) const BOOST_NOEXCEPT
Bucket> const& other) const noexcept
{
return equal(other);
}
bool operator!=(
boost::unordered::detail::iterator_detail::c_iterator<Node,
Bucket> const& other) const BOOST_NOEXCEPT
Bucket> const& other) const noexcept
{
return !equal(other);
}
@ -1684,21 +1687,18 @@ namespace boost {
iterator(node_pointer p_, bucket_iterator itb_) : p(p_), itb(itb_) {}
value_type& dereference() const BOOST_NOEXCEPT { return p->value(); }
value_type& dereference() const noexcept { return p->value(); }
bool equal(const iterator& x) const BOOST_NOEXCEPT
{
return (p == x.p);
}
bool equal(const iterator& x) const noexcept { return (p == x.p); }
bool equal(
const boost::unordered::detail::iterator_detail::c_iterator<Node,
Bucket>& x) const BOOST_NOEXCEPT
Bucket>& x) const noexcept
{
return (p == x.p);
}
void increment() BOOST_NOEXCEPT
void increment() noexcept
{
p = p->next;
if (!p) {
@ -1706,10 +1706,10 @@ namespace boost {
}
}
template<typename Archive>
template <typename Archive>
friend void serialization_track(Archive& ar, const iterator& x)
{
if(x.p){
if (x.p) {
track_address(ar, x.p);
serialization_track(ar, x.itb);
}
@ -1717,12 +1717,12 @@ namespace boost {
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive& ar,unsigned int)
template <typename Archive> void serialize(Archive& ar, unsigned int)
{
if(!p) itb = bucket_iterator();
if (!p)
itb = bucket_iterator();
serialize_tracked_address(ar, p);
ar & core::make_nvp("bucket_iterator", itb);
ar& core::make_nvp("bucket_iterator", itb);
}
};
@ -1736,49 +1736,49 @@ namespace boost {
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
c_iterator() : p(), itb(){}
c_iterator() : p(), itb() {}
c_iterator(iterator<Node, Bucket> it) : p(it.p), itb(it.itb) {}
reference operator*() const BOOST_NOEXCEPT { return dereference(); }
pointer operator->() const BOOST_NOEXCEPT
reference operator*() const noexcept { return dereference(); }
pointer operator->() const noexcept
{
pointer x = boost::addressof(p->value());
return x;
}
c_iterator& operator++() BOOST_NOEXCEPT
c_iterator& operator++() noexcept
{
increment();
return *this;
}
c_iterator operator++(int) BOOST_NOEXCEPT
c_iterator operator++(int) noexcept
{
c_iterator old = *this;
increment();
return old;
}
bool operator==(c_iterator const& other) const BOOST_NOEXCEPT
bool operator==(c_iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(c_iterator const& other) const BOOST_NOEXCEPT
bool operator!=(c_iterator const& other) const noexcept
{
return !equal(other);
}
bool operator==(
boost::unordered::detail::iterator_detail::iterator<Node,
Bucket> const& other) const BOOST_NOEXCEPT
Bucket> const& other) const noexcept
{
return equal(other);
}
bool operator!=(
boost::unordered::detail::iterator_detail::iterator<Node,
Bucket> const& other) const BOOST_NOEXCEPT
Bucket> const& other) const noexcept
{
return !equal(other);
}
@ -1797,17 +1797,11 @@ namespace boost {
{
}
value_type const& dereference() const BOOST_NOEXCEPT
{
return p->value();
}
value_type const& dereference() const noexcept { return p->value(); }
bool equal(const c_iterator& x) const BOOST_NOEXCEPT
{
return (p == x.p);
}
bool equal(const c_iterator& x) const noexcept { return (p == x.p); }
void increment() BOOST_NOEXCEPT
void increment() noexcept
{
p = p->next;
if (!p) {
@ -1815,10 +1809,10 @@ namespace boost {
}
}
template<typename Archive>
template <typename Archive>
friend void serialization_track(Archive& ar, const c_iterator& x)
{
if(x.p){
if (x.p) {
track_address(ar, x.p);
serialization_track(ar, x.itb);
}
@ -1826,12 +1820,12 @@ namespace boost {
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive& ar,unsigned int)
template <typename Archive> void serialize(Archive& ar, unsigned int)
{
if(!p) itb = bucket_iterator();
if (!p)
itb = bucket_iterator();
serialize_tracked_address(ar, p);
ar & core::make_nvp("bucket_iterator", itb);
ar& core::make_nvp("bucket_iterator", itb);
}
};
} // namespace iterator_detail
@ -1859,20 +1853,23 @@ namespace boost {
functions;
typedef typename Types::value_allocator value_allocator;
typedef typename boost::allocator_void_pointer<value_allocator>::type void_pointer;
typedef typename boost::allocator_void_pointer<value_allocator>::type
void_pointer;
typedef node<value_type, void_pointer> node_type;
typedef boost::unordered::detail::grouped_bucket_array<
bucket<node_type, void_pointer>, value_allocator, prime_fmod_size<> >
bucket_array_type;
typedef typename bucket_array_type::node_allocator_type
node_allocator_type;
typedef typename boost::allocator_pointer<node_allocator_type>::type node_pointer;
typedef
typename bucket_array_type::node_allocator_type node_allocator_type;
typedef typename boost::allocator_pointer<node_allocator_type>::type
node_pointer;
typedef boost::unordered::detail::node_constructor<node_allocator_type>
node_constructor;
typedef boost::unordered::detail::node_tmp<node_allocator_type> node_tmp;
typedef boost::unordered::detail::node_tmp<node_allocator_type>
node_tmp;
typedef typename bucket_array_type::bucket_type bucket_type;
@ -1919,8 +1916,7 @@ namespace boost {
}
std::size_t c = 0;
std::size_t const key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
bool found = false;
@ -1962,10 +1958,7 @@ namespace boost {
return iterator(itb->next, itb);
}
iterator end() const
{
return iterator();
}
iterator end() const { return iterator(); }
l_iterator begin(std::size_t bucket_index) const
{
@ -2142,8 +2135,7 @@ namespace boost {
return;
}
BOOST_ASSERT(
buckets_.bucket_count() == src.buckets_.bucket_count());
BOOST_ASSERT(buckets_.bucket_count() == src.buckets_.bucket_count());
this->reserve(src.size_);
for (iterator pos = src.begin(); pos != src.end(); ++pos) {
@ -2154,8 +2146,7 @@ namespace boost {
const_key_type& k = this->get_key(b.node_);
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
buckets_.insert_node(itb, b.release());
++size_;
}
@ -2201,7 +2192,9 @@ namespace boost {
template <typename UniqueType>
void assign(table const& x, UniqueType is_unique)
{
typedef typename boost::allocator_propagate_on_container_copy_assignment<node_allocator_type>::type pocca;
typedef
typename boost::allocator_propagate_on_container_copy_assignment<
node_allocator_type>::type pocca;
if (this != &x) {
assign(x, is_unique,
@ -2211,7 +2204,7 @@ namespace boost {
}
template <typename UniqueType>
void assign(table const &x, UniqueType is_unique, false_type)
void assign(table const& x, UniqueType is_unique, false_type)
{
// Strong exception safety.
this->construct_spare_functions(x.current_functions());
@ -2234,15 +2227,12 @@ namespace boost {
}
template <typename UniqueType>
void assign(table const &x, UniqueType is_unique, true_type)
void assign(table const& x, UniqueType is_unique, true_type)
{
if (node_alloc() == x.node_alloc())
{
if (node_alloc() == x.node_alloc()) {
buckets_.reset_allocator(x.node_alloc());
assign(x, is_unique, false_type());
}
else
{
} else {
bucket_array_type new_buckets(x.size_, x.node_alloc());
this->construct_spare_functions(x.current_functions());
this->switch_functions();
@ -2258,8 +2248,7 @@ namespace boost {
reserve(x.size_);
// Finally copy the elements.
if (x.size_)
{
if (x.size_) {
copy_buckets(x, is_unique);
}
}
@ -2347,8 +2336,7 @@ namespace boost {
return extractor::extract(n->value());
}
template <class Key>
std::size_t hash(Key const& k) const
template <class Key> std::size_t hash(Key const& k) const
{
return this->hash_function()(k);
}
@ -2356,8 +2344,7 @@ namespace boost {
// Find Node
template <class Key>
node_pointer find_node_impl(
Key const& x, bucket_iterator itb) const
node_pointer find_node_impl(Key const& x, bucket_iterator itb) const
{
node_pointer p = node_pointer();
if (itb != buckets_.end()) {
@ -2375,12 +2362,10 @@ namespace boost {
template <class Key> node_pointer find_node(Key const& k) const
{
std::size_t const key_hash = this->hash(k);
return find_node_impl(
k, buckets_.at(buckets_.position(key_hash)));
return find_node_impl(k, buckets_.at(buckets_.position(key_hash)));
}
node_pointer find_node(
const_key_type& k, bucket_iterator itb) const
node_pointer find_node(const_key_type& k, bucket_iterator itb) const
{
return find_node_impl(k, itb);
}
@ -2414,7 +2399,7 @@ namespace boost {
if (size_ > 0) {
key_equal pred = this->key_eq();
for (node_pointer* pp = boost::addressof(itb->next); *pp;
pp = boost::addressof((*pp)->next)) {
pp = boost::addressof((*pp)->next)) {
if (pred(key, extractor::extract((*pp)->value()))) {
return pp;
}
@ -2508,8 +2493,7 @@ namespace boost {
const_key_type& k, BOOST_UNORDERED_EMPLACE_ARGS)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
@ -2546,8 +2530,7 @@ namespace boost {
}
std::size_t const key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
@ -2575,8 +2558,7 @@ namespace boost {
const_key_type& k = this->get_key(b.node_);
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
@ -2599,8 +2581,7 @@ namespace boost {
emplace_return try_emplace_unique(BOOST_FWD_REF(Key) k)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
@ -2643,8 +2624,7 @@ namespace boost {
BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
@ -2685,8 +2665,7 @@ namespace boost {
BOOST_FWD_REF(Key) k, BOOST_FWD_REF(M) obj)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
@ -2723,8 +2702,7 @@ namespace boost {
const_key_type& k = this->get_key(np.ptr_);
std::size_t const key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
@ -2762,8 +2740,7 @@ namespace boost {
}
std::size_t const key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
return iterator(p, itb);
@ -2786,8 +2763,8 @@ namespace boost {
void merge_unique(boost::unordered::detail::table<Types2>& other)
{
typedef boost::unordered::detail::table<Types2> other_table;
BOOST_STATIC_ASSERT((boost::is_same<node_type,
typename other_table::node_type>::value));
BOOST_STATIC_ASSERT((
boost::is_same<node_type, typename other_table::node_type>::value));
BOOST_ASSERT(this->node_alloc() == other.node_alloc());
if (other.size_ == 0) {
@ -2801,8 +2778,7 @@ namespace boost {
const_key_type& key = other.get_key(pos.p);
std::size_t const key_hash = this->hash(key);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
if (this->find_node_impl(key, itb)) {
++pos;
@ -2887,10 +2863,11 @@ namespace boost {
return 1;
}
iterator erase_node(c_iterator pos) {
iterator erase_node(c_iterator pos)
{
c_iterator next = pos;
++next;
bucket_iterator itb = pos.itb;
node_pointer* pp = boost::addressof(itb->next);
while (*pp != pos.p) {
@ -2927,7 +2904,6 @@ namespace boost {
this->delete_node(p);
--size_;
bool const at_end = !(*pp);
bool const is_empty_bucket = !itb->next;
@ -3022,8 +2998,8 @@ namespace boost {
return true;
}
static bool group_equals_equiv(iterator n1, iterator end1,
iterator n2, iterator end2)
static bool group_equals_equiv(
iterator n1, iterator end1, iterator n2, iterator end2)
{
for (;;) {
if (*n1 != *n2)
@ -3071,8 +3047,7 @@ namespace boost {
return true;
}
static bool find_equiv(
iterator n, iterator last, value_type const& v)
static bool find_equiv(iterator n, iterator last, value_type const& v)
{
for (; n != last; ++n)
if (*n == v)
@ -3097,8 +3072,7 @@ namespace boost {
node_tmp a(n, this->node_alloc());
const_key_type& k = this->get_key(a.node_);
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer hint = this->find_node_impl(k, itb);
if (size_ + 1 > max_load_) {
@ -3166,8 +3140,7 @@ namespace boost {
const_key_type& k = this->get_key(np.ptr_);
std::size_t key_hash = this->hash(k);
bucket_iterator itb =
buckets_.at(buckets_.position(key_hash));
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer hint = this->find_node_impl(k, itb);
buckets_.insert_node_hint(itb, np.ptr_, hint);
@ -3634,9 +3607,9 @@ namespace boost {
return (size - c.size());
}
}
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
#undef BOOST_UNORDERED_EMPLACE_TEMPLATE
#undef BOOST_UNORDERED_EMPLACE_ARGS

2
include/boost/unordered/detail/narrow_cast.hpp
View File

@ -19,7 +19,7 @@ namespace unordered{
namespace detail{
template<typename To,typename From>
BOOST_CONSTEXPR To narrow_cast(From x) BOOST_NOEXCEPT
BOOST_CONSTEXPR To narrow_cast(From x) noexcept
{
BOOST_STATIC_ASSERT(boost::is_integral<From>::value);
BOOST_STATIC_ASSERT(boost::is_integral<To>::value);

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

@ -14,15 +14,15 @@
#pragma once
#endif
#include <boost/unordered/detail/map.hpp>
#include <boost/unordered/detail/requires_cxx11.hpp>
#include <boost/config.hpp>
#include <boost/unordered/detail/serialize_fca_container.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/core/explicit_operator_bool.hpp>
#include <boost/functional/hash.hpp>
#include <boost/move/move.hpp>
#include <boost/type_traits/is_constructible.hpp>
#include <boost/unordered/detail/map.hpp>
#include <boost/unordered/detail/serialize_fca_container.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>
@ -99,10 +99,10 @@ namespace boost {
unordered_map(unordered_map const&);
#if defined(BOOST_UNORDERED_USE_MOVE) || \
#if defined(BOOST_UNORDERED_USE_MOVE) || \
!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_map(BOOST_RV_REF(unordered_map) other)
BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
noexcept(table::nothrow_move_constructible)
: table_(other.table_, boost::unordered::detail::move_tag())
{
// The move is done in table_
@ -148,9 +148,9 @@ namespace boost {
// Destructor
~unordered_map() BOOST_NOEXCEPT;
~unordered_map() noexcept;
// Assign
// Assign
#if defined(BOOST_UNORDERED_USE_MOVE)
unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
@ -160,7 +160,7 @@ namespace boost {
}
unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -176,7 +176,7 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_map& operator=(unordered_map&& x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -190,43 +190,43 @@ namespace boost {
unordered_map& operator=(std::initializer_list<value_type>);
#endif
allocator_type get_allocator() const BOOST_NOEXCEPT
allocator_type get_allocator() const noexcept
{
return table_.node_alloc();
}
// // iterators
// // iterators
iterator begin() BOOST_NOEXCEPT { return table_.begin(); }
iterator begin() noexcept { return table_.begin(); }
const_iterator begin() const BOOST_NOEXCEPT
const_iterator begin() const noexcept
{
return const_iterator(table_.begin());
}
iterator end() BOOST_NOEXCEPT { return iterator(); }
iterator end() noexcept { return iterator(); }
const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator end() const noexcept { return const_iterator(); }
const_iterator cbegin() const BOOST_NOEXCEPT
const_iterator cbegin() const noexcept
{
return const_iterator(table_.begin());
}
const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator cend() const noexcept { return const_iterator(); }
// size and capacity
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return table_.size_ == 0;
}
size_type size() const BOOST_NOEXCEPT { return table_.size_; }
size_type size() const noexcept { return table_.size_; }
size_type max_size() const BOOST_NOEXCEPT;
size_type max_size() const noexcept;
// emplace
// emplace
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -397,7 +397,8 @@ namespace boost {
template <class P2>
typename boost::enable_if<
boost::is_constructible<value_type, BOOST_RV_REF(P2)>,
std::pair<iterator, bool> >::type insert(BOOST_RV_REF(P2) obj)
std::pair<iterator, bool> >::type
insert(BOOST_RV_REF(P2) obj)
{
return this->emplace(boost::forward<P2>(obj));
}
@ -647,18 +648,18 @@ namespace boost {
iterator try_emplace(
const_iterator hint, key_type const& k, BOOST_FWD_REF(A0) a0)
{
return table_.try_emplace_hint_unique(
hint, k, boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0)));
return table_.try_emplace_hint_unique(hint, k,
boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0)));
}
template <typename A0, typename A1>
iterator try_emplace(const_iterator hint, key_type const& k,
BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
{
return table_.try_emplace_hint_unique(
hint, k, boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0), boost::forward<A1>(a1)));
return table_.try_emplace_hint_unique(hint, k,
boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0), boost::forward<A1>(a1)));
}
template <typename A0, typename A1, typename A2>
@ -676,9 +677,9 @@ namespace boost {
iterator try_emplace(
const_iterator hint, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(A0) a0)
{
return table_.try_emplace_hint_unique(
hint, boost::move(k), boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0)));
return table_.try_emplace_hint_unique(hint, boost::move(k),
boost::unordered::detail::create_emplace_args(
boost::forward<A0>(a0)));
}
template <typename A0, typename A1>
@ -761,9 +762,9 @@ namespace boost {
iterator try_emplace(const_iterator hint, key_type const& k, \
BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)) \
{ \
return table_.try_emplace_hint_unique( \
hint, k, boost::unordered::detail::create_emplace_args( \
BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
return table_.try_emplace_hint_unique(hint, k, \
boost::unordered::detail::create_emplace_args( \
BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
} \
\
template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
@ -860,10 +861,10 @@ namespace boost {
void erase_return_void(const_iterator it) { erase(it); }
void swap(unordered_map&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
void clear() noexcept { table_.clear_impl(); }
template <typename H2, typename P2>
void merge(boost::unordered_map<K, T, H2, P2, A>& source);
@ -993,12 +994,9 @@ namespace boost {
// bucket interface
size_type bucket_count() const BOOST_NOEXCEPT
{
return table_.bucket_count();
}
size_type bucket_count() const noexcept { return table_.bucket_count(); }
size_type max_bucket_count() const BOOST_NOEXCEPT
size_type max_bucket_count() const noexcept
{
return table_.max_bucket_count();
}
@ -1018,10 +1016,7 @@ namespace boost {
return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
}
local_iterator begin(size_type n)
{
return table_.begin(n);
}
local_iterator begin(size_type n) { return table_.begin(n); }
const_local_iterator begin(size_type n) const
{
@ -1046,9 +1041,9 @@ namespace boost {
// hash policy
float load_factor() const BOOST_NOEXCEPT;
float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
void max_load_factor(float) BOOST_NOEXCEPT;
float load_factor() const noexcept;
float max_load_factor() const noexcept { return table_.mlf_; }
void max_load_factor(float) noexcept;
void rehash(size_type);
void reserve(size_type);
@ -1062,7 +1057,7 @@ namespace boost {
template <class Archive, class K, class T, class H, class P, class A>
void serialize(
Archive & ar,unordered_map<K, T, H, P, A>& m,unsigned int version)
Archive& ar, unordered_map<K, T, H, P, A>& m, unsigned int version)
{
detail::serialize_fca_container(ar, m, version);
}
@ -1213,7 +1208,7 @@ namespace boost {
#if defined(BOOST_UNORDERED_USE_MOVE) || \
!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
noexcept(table::nothrow_move_constructible)
: table_(other.table_, boost::unordered::detail::move_tag())
{
// The move is done in table_
@ -1262,9 +1257,9 @@ namespace boost {
// Destructor
~unordered_multimap() BOOST_NOEXCEPT;
~unordered_multimap() noexcept;
// Assign
// Assign
#if defined(BOOST_UNORDERED_USE_MOVE)
unordered_multimap& operator=(BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
@ -1274,7 +1269,7 @@ namespace boost {
}
unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -1290,7 +1285,7 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multimap& operator=(unordered_multimap&& x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -1304,43 +1299,43 @@ namespace boost {
unordered_multimap& operator=(std::initializer_list<value_type>);
#endif
allocator_type get_allocator() const BOOST_NOEXCEPT
allocator_type get_allocator() const noexcept
{
return table_.node_alloc();
}
// iterators
iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
iterator begin() noexcept { return iterator(table_.begin()); }
const_iterator begin() const BOOST_NOEXCEPT
const_iterator begin() const noexcept
{
return const_iterator(table_.begin());
}
iterator end() BOOST_NOEXCEPT { return iterator(); }
iterator end() noexcept { return iterator(); }
const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator end() const noexcept { return const_iterator(); }
const_iterator cbegin() const BOOST_NOEXCEPT
const_iterator cbegin() const noexcept
{
return const_iterator(table_.begin());
}
const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator cend() const noexcept { return const_iterator(); }
// size and capacity
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return table_.size_ == 0;
}
size_type size() const BOOST_NOEXCEPT { return table_.size_; }
size_type size() const noexcept { return table_.size_; }
size_type max_size() const BOOST_NOEXCEPT;
size_type max_size() const noexcept;
// emplace
// emplace
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -1504,8 +1499,8 @@ namespace boost {
template <class P2>
typename boost::enable_if<
boost::is_constructible<value_type, BOOST_RV_REF(P2)>,
iterator>::type insert(BOOST_RV_REF(P2) obj)
boost::is_constructible<value_type, BOOST_RV_REF(P2)>, iterator>::type
insert(BOOST_RV_REF(P2) obj)
{
return this->emplace(boost::forward<P2>(obj));
}
@ -1522,8 +1517,7 @@ namespace boost {
template <class P2>
typename boost::enable_if<
boost::is_constructible<value_type, BOOST_RV_REF(P2)>,
iterator>::type
boost::is_constructible<value_type, BOOST_RV_REF(P2)>, iterator>::type
insert(const_iterator hint, BOOST_RV_REF(P2) obj)
{
return this->emplace_hint(hint, boost::forward<P2>(obj));
@ -1597,10 +1591,10 @@ namespace boost {
void erase_return_void(const_iterator it) { erase(it); }
void swap(unordered_multimap&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
void clear() noexcept { table_.clear_impl(); }
template <typename H2, typename P2>
void merge(boost::unordered_multimap<K, T, H2, P2, A>& source);
@ -1702,12 +1696,9 @@ namespace boost {
// bucket interface
size_type bucket_count() const BOOST_NOEXCEPT
{
return table_.bucket_count();
}
size_type bucket_count() const noexcept { return table_.bucket_count(); }
size_type max_bucket_count() const BOOST_NOEXCEPT
size_type max_bucket_count() const noexcept
{
return table_.max_bucket_count();
}
@ -1756,9 +1747,9 @@ namespace boost {
// hash policy
float load_factor() const BOOST_NOEXCEPT;
float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
void max_load_factor(float) BOOST_NOEXCEPT;
float load_factor() const noexcept;
float max_load_factor() const noexcept { return table_.mlf_; }
void max_load_factor(float) noexcept;
void rehash(size_type);
void reserve(size_type);
@ -1772,7 +1763,7 @@ namespace boost {
template <class Archive, class K, class T, class H, class P, class A>
void serialize(
Archive & ar,unordered_multimap<K, T, H, P, A>& m,unsigned int version)
Archive& ar, unordered_multimap<K, T, H, P, A>& m, unsigned int version)
{
detail::serialize_fca_container(ar, m, version);
}
@ -2023,7 +2014,7 @@ namespace boost {
#endif
template <class K, class T, class H, class P, class A>
unordered_map<K, T, H, P, A>::~unordered_map() BOOST_NOEXCEPT
unordered_map<K, T, H, P, A>::~unordered_map() noexcept
{
}
@ -2043,7 +2034,7 @@ namespace boost {
// size and capacity
template <class K, class T, class H, class P, class A>
std::size_t unordered_map<K, T, H, P, A>::max_size() const BOOST_NOEXCEPT
std::size_t unordered_map<K, T, H, P, A>::max_size() const noexcept
{
using namespace std;
@ -2106,7 +2097,7 @@ 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&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
@ -2236,14 +2227,14 @@ namespace boost {
template <class K, class T, class H, class P, class A>
typename unordered_map<K, T, H, P, A>::mapped_type&
unordered_map<K, T, H, P, A>::operator[](const key_type& k)
unordered_map<K, T, H, P, A>::operator[](const key_type& k)
{
return table_.try_emplace_unique(k).first->second;
}
template <class K, class T, class H, class P, class A>
typename unordered_map<K, T, H, P, A>::mapped_type&
unordered_map<K, T, H, P, A>::operator[](BOOST_RV_REF(key_type) k)
unordered_map<K, T, H, P, A>::operator[](BOOST_RV_REF(key_type) k)
{
return table_.try_emplace_unique(boost::move(k)).first->second;
}
@ -2335,7 +2326,7 @@ namespace boost {
// hash policy
template <class K, class T, class H, class P, class A>
float unordered_map<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
float unordered_map<K, T, H, P, A>::load_factor() const noexcept
{
if (table_.size_ == 0) {
return 0.0f;
@ -2347,7 +2338,7 @@ namespace boost {
}
template <class K, class T, class H, class P, class A>
void unordered_map<K, T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
void unordered_map<K, T, H, P, A>::max_load_factor(float m) noexcept
{
table_.max_load_factor(m);
}
@ -2391,9 +2382,8 @@ namespace boost {
}
template <class K, class T, class H, class P, class A>
inline void swap(
unordered_map<K, T, H, P, A>& m1, unordered_map<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
inline void swap(unordered_map<K, T, H, P, A>& m1,
unordered_map<K, T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
{
#if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
struct dummy
@ -2572,15 +2562,16 @@ namespace boost {
#endif
template <class K, class T, class H, class P, class A>
unordered_multimap<K, T, H, P, A>::~unordered_multimap() BOOST_NOEXCEPT
unordered_multimap<K, T, H, P, A>::~unordered_multimap() noexcept
{
}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
template <class K, class T, class H, class P, class A>
unordered_multimap<K, T, H, P, A>& unordered_multimap<K, T, H, P, A>::
operator=(std::initializer_list<value_type> list)
unordered_multimap<K, T, H, P, A>&
unordered_multimap<K, T, H, P, A>::operator=(
std::initializer_list<value_type> list)
{
this->clear();
this->insert(list.begin(), list.end());
@ -2592,8 +2583,7 @@ namespace boost {
// size and capacity
template <class K, class T, class H, class P, class A>
std::size_t
unordered_multimap<K, T, H, P, A>::max_size() const BOOST_NOEXCEPT
std::size_t unordered_multimap<K, T, H, P, A>::max_size() const noexcept
{
using namespace std;
@ -2655,7 +2645,7 @@ 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&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
@ -2795,7 +2785,7 @@ namespace boost {
// hash policy
template <class K, class T, class H, class P, class A>
float unordered_multimap<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
float unordered_multimap<K, T, H, P, A>::load_factor() const noexcept
{
if (table_.size_ == 0) {
return 0.0f;
@ -2807,8 +2797,7 @@ namespace boost {
}
template <class K, class T, class H, class P, class A>
void unordered_multimap<K, T, H, P, A>::max_load_factor(
float m) BOOST_NOEXCEPT
void unordered_multimap<K, T, H, P, A>::max_load_factor(float m) noexcept
{
table_.max_load_factor(m);
}
@ -2853,8 +2842,7 @@ namespace boost {
template <class K, class T, class H, class P, class A>
inline void swap(unordered_multimap<K, T, H, P, A>& m1,
unordered_multimap<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
unordered_multimap<K, T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
{
#if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
struct dummy
@ -2906,7 +2894,7 @@ namespace boost {
}
public:
BOOST_CONSTEXPR node_handle_map() BOOST_NOEXCEPT : ptr_(), alloc_() {}
BOOST_CONSTEXPR node_handle_map() noexcept : ptr_(), alloc_() {}
~node_handle_map()
{
@ -2917,7 +2905,7 @@ namespace boost {
}
}
node_handle_map(BOOST_RV_REF(node_handle_map) n) BOOST_NOEXCEPT
node_handle_map(BOOST_RV_REF(node_handle_map) n) noexcept
: ptr_(n.ptr_),
alloc_(boost::move(n.alloc_))
{
@ -2960,17 +2948,17 @@ namespace boost {
BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
bool operator!() const noexcept { return ptr_ ? 0 : 1; }
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return ptr_ ? 0 : 1;
}
void swap(node_handle_map& n) BOOST_NOEXCEPT_IF(
boost::allocator_propagate_on_container_swap<
value_allocator>::type::value ||
boost::allocator_is_always_equal<value_allocator>::type::value)
void swap(node_handle_map& n)
noexcept(boost::allocator_propagate_on_container_swap<
value_allocator>::type::value ||
boost::allocator_is_always_equal<value_allocator>::type::value)
{
BOOST_ASSERT(!alloc_.has_value() || !n.alloc_.has_value() ||
@ -2988,7 +2976,7 @@ namespace boost {
template <class N, class K, class T, class A>
void swap(node_handle_map<N, K, T, A>& x, node_handle_map<N, K, T, A>& y)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
noexcept(noexcept(x.swap(y)))
{
x.swap(y);
}
@ -3009,10 +2997,10 @@ namespace boost {
insert_return_type_map() : position(), inserted(false), node() {}
insert_return_type_map(BOOST_RV_REF(insert_return_type_map)
x) BOOST_NOEXCEPT : position(x.position),
inserted(x.inserted),
node(boost::move(x.node))
insert_return_type_map(BOOST_RV_REF(insert_return_type_map) x) noexcept
: position(x.position),
inserted(x.inserted),
node(boost::move(x.node))
{
}

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

@ -1,6 +1,6 @@
// Copyright (C) 2008-2011 Daniel James.
// Copyright (C) 2022 Christian Mazakas
// Copyright (C) 2022-2023 Christian Mazakas
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -30,9 +30,8 @@ namespace boost {
inline bool operator!=(
unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
template <class K, class T, class H, class P, class A>
inline void swap(
unordered_map<K, T, H, P, A>& m1, unordered_map<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
inline void swap(unordered_map<K, T, H, P, A>& m1,
unordered_map<K, T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)));
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type erase_if(
@ -51,8 +50,7 @@ namespace boost {
unordered_multimap<K, T, H, P, A> const&);
template <class K, class T, class H, class P, class A>
inline void swap(unordered_multimap<K, T, H, P, A>& m1,
unordered_multimap<K, T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
unordered_multimap<K, T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)));
template <class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type erase_if(
@ -60,13 +58,13 @@ namespace boost {
template <class N, class K, class T, class A> class node_handle_map;
template <class Iter, class NodeType> struct insert_return_type_map;
}
} // namespace unordered
using boost::unordered::swap;
using boost::unordered::unordered_map;
using boost::unordered::unordered_multimap;
using boost::unordered::swap;
using boost::unordered::operator==;
using boost::unordered::operator!=;
}
} // namespace boost
#endif

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

@ -15,12 +15,13 @@
#endif
#include <boost/unordered/detail/requires_cxx11.hpp>
#include <boost/unordered/detail/serialize_fca_container.hpp>
#include <boost/unordered/detail/set.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/core/explicit_operator_bool.hpp>
#include <boost/functional/hash.hpp>
#include <boost/move/move.hpp>
#include <boost/unordered/detail/set.hpp>
#include <boost/unordered/detail/serialize_fca_container.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list>
@ -99,7 +100,7 @@ namespace boost {
#if defined(BOOST_UNORDERED_USE_MOVE) || \
!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_set(BOOST_RV_REF(unordered_set) other)
BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
noexcept(table::nothrow_move_constructible)
: table_(other.table_, boost::unordered::detail::move_tag())
{
// The move is done in table_
@ -145,9 +146,9 @@ namespace boost {
// Destructor
~unordered_set() BOOST_NOEXCEPT;
~unordered_set() noexcept;
// Assign
// Assign
#if defined(BOOST_UNORDERED_USE_MOVE)
unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
@ -157,7 +158,7 @@ namespace boost {
}
unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -173,7 +174,7 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_set& operator=(unordered_set&& x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -187,43 +188,43 @@ namespace boost {
unordered_set& operator=(std::initializer_list<value_type>);
#endif
allocator_type get_allocator() const BOOST_NOEXCEPT
allocator_type get_allocator() const noexcept
{
return table_.node_alloc();
}
// iterators
iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
iterator begin() noexcept { return iterator(table_.begin()); }
const_iterator begin() const BOOST_NOEXCEPT
const_iterator begin() const noexcept
{
return const_iterator(table_.begin());
}
iterator end() BOOST_NOEXCEPT { return iterator(); }
iterator end() noexcept { return iterator(); }
const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator end() const noexcept { return const_iterator(); }
const_iterator cbegin() const BOOST_NOEXCEPT
const_iterator cbegin() const noexcept
{
return const_iterator(table_.begin());
}
const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator cend() const noexcept { return const_iterator(); }
// size and capacity
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return table_.size_ == 0;
}
size_type size() const BOOST_NOEXCEPT { return table_.size_; }
size_type size() const noexcept { return table_.size_; }
size_type max_size() const BOOST_NOEXCEPT;
size_type max_size() const noexcept;
// emplace
// emplace
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -488,10 +489,10 @@ namespace boost {
void erase_return_void(const_iterator it) { erase(it); }
void swap(unordered_set&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
void clear() noexcept { table_.clear_impl(); }
template <typename H2, typename P2>
void merge(boost::unordered_set<T, H2, P2, A>& source);
@ -573,12 +574,9 @@ namespace boost {
// bucket interface
size_type bucket_count() const BOOST_NOEXCEPT
{
return table_.bucket_count();
}
size_type bucket_count() const noexcept { return table_.bucket_count(); }
size_type max_bucket_count() const BOOST_NOEXCEPT
size_type max_bucket_count() const noexcept
{
return table_.max_bucket_count();
}
@ -627,9 +625,9 @@ namespace boost {
// hash policy
float load_factor() const BOOST_NOEXCEPT;
float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
void max_load_factor(float) BOOST_NOEXCEPT;
float load_factor() const noexcept;
float max_load_factor() const noexcept { return table_.mlf_; }
void max_load_factor(float) noexcept;
void rehash(size_type);
void reserve(size_type);
@ -643,7 +641,7 @@ namespace boost {
template <class Archive, class K, class H, class P, class A>
void serialize(
Archive & ar,unordered_set<K, H, P, A>& c,unsigned int version)
Archive& ar, unordered_set<K, H, P, A>& c, unsigned int version)
{
detail::serialize_fca_container(ar, c, version);
}
@ -782,7 +780,7 @@ namespace boost {
#if defined(BOOST_UNORDERED_USE_MOVE) || \
!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
noexcept(table::nothrow_move_constructible)
: table_(other.table_, boost::unordered::detail::move_tag())
{
// The move is done in table_
@ -831,9 +829,9 @@ namespace boost {
// Destructor
~unordered_multiset() BOOST_NOEXCEPT;
~unordered_multiset() noexcept;
// Assign
// Assign
#if defined(BOOST_UNORDERED_USE_MOVE)
unordered_multiset& operator=(BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
@ -843,7 +841,7 @@ namespace boost {
}
unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -859,7 +857,7 @@ namespace boost {
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
unordered_multiset& operator=(unordered_multiset&& x)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_move_assignable<H>::value&&
boost::is_nothrow_move_assignable<P>::value)
{
@ -873,43 +871,43 @@ namespace boost {
unordered_multiset& operator=(std::initializer_list<value_type>);
#endif
allocator_type get_allocator() const BOOST_NOEXCEPT
allocator_type get_allocator() const noexcept
{
return table_.node_alloc();
}
// iterators
iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
iterator begin() noexcept { return iterator(table_.begin()); }
const_iterator begin() const BOOST_NOEXCEPT
const_iterator begin() const noexcept
{
return const_iterator(table_.begin());
}
iterator end() BOOST_NOEXCEPT { return iterator(); }
iterator end() noexcept { return iterator(); }
const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator end() const noexcept { return const_iterator(); }
const_iterator cbegin() const BOOST_NOEXCEPT
const_iterator cbegin() const noexcept
{
return const_iterator(table_.begin());
}
const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
const_iterator cend() const noexcept { return const_iterator(); }
// size and capacity
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return table_.size_ == 0;
}
size_type size() const BOOST_NOEXCEPT { return table_.size_; }
size_type size() const noexcept { return table_.size_; }
size_type max_size() const BOOST_NOEXCEPT;
size_type max_size() const noexcept;
// emplace
// emplace
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -1148,10 +1146,10 @@ namespace boost {
void erase_return_void(const_iterator it) { erase(it); }
void swap(unordered_multiset&)
BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value);
void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
void clear() noexcept { table_.clear_impl(); }
template <typename H2, typename P2>
void merge(boost::unordered_multiset<T, H2, P2, A>& source);
@ -1229,12 +1227,9 @@ namespace boost {
// bucket interface
size_type bucket_count() const BOOST_NOEXCEPT
{
return table_.bucket_count();
}
size_type bucket_count() const noexcept { return table_.bucket_count(); }
size_type max_bucket_count() const BOOST_NOEXCEPT
size_type max_bucket_count() const noexcept
{
return table_.max_bucket_count();
}
@ -1283,9 +1278,9 @@ namespace boost {
// hash policy
float load_factor() const BOOST_NOEXCEPT;
float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
void max_load_factor(float) BOOST_NOEXCEPT;
float load_factor() const noexcept;
float max_load_factor() const noexcept { return table_.mlf_; }
void max_load_factor(float) noexcept;
void rehash(size_type);
void reserve(size_type);
@ -1299,7 +1294,7 @@ namespace boost {
template <class Archive, class K, class H, class P, class A>
void serialize(
Archive & ar,unordered_multiset<K, H, P, A>& c,unsigned int version)
Archive& ar, unordered_multiset<K, H, P, A>& c, unsigned int version)
{
detail::serialize_fca_container(ar, c, version);
}
@ -1540,7 +1535,7 @@ namespace boost {
#endif
template <class T, class H, class P, class A>
unordered_set<T, H, P, A>::~unordered_set() BOOST_NOEXCEPT
unordered_set<T, H, P, A>::~unordered_set() noexcept
{
}
@ -1560,7 +1555,7 @@ namespace boost {
// size and capacity
template <class T, class H, class P, class A>
std::size_t unordered_set<T, H, P, A>::max_size() const BOOST_NOEXCEPT
std::size_t unordered_set<T, H, P, A>::max_size() const noexcept
{
using namespace std;
@ -1615,7 +1610,7 @@ 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&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
@ -1723,7 +1718,7 @@ namespace boost {
// hash policy
template <class T, class H, class P, class A>
float unordered_set<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
float unordered_set<T, H, P, A>::load_factor() const noexcept
{
if (table_.size_ == 0) {
return 0.0f;
@ -1735,7 +1730,7 @@ namespace boost {
}
template <class T, class H, class P, class A>
void unordered_set<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
void unordered_set<T, H, P, A>::max_load_factor(float m) noexcept
{
table_.max_load_factor(m);
}
@ -1779,9 +1774,8 @@ namespace boost {
}
template <class T, class H, class P, class A>
inline void swap(
unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
inline void swap(unordered_set<T, H, P, A>& m1,
unordered_set<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
{
#if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
struct dummy
@ -1959,7 +1953,7 @@ namespace boost {
#endif
template <class T, class H, class P, class A>
unordered_multiset<T, H, P, A>::~unordered_multiset() BOOST_NOEXCEPT
unordered_multiset<T, H, P, A>::~unordered_multiset() noexcept
{
}
@ -1979,7 +1973,7 @@ namespace boost {
// size and capacity
template <class T, class H, class P, class A>
std::size_t unordered_multiset<T, H, P, A>::max_size() const BOOST_NOEXCEPT
std::size_t unordered_multiset<T, H, P, A>::max_size() const noexcept
{
using namespace std;
@ -2033,7 +2027,7 @@ 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&&
noexcept(value_allocator_traits::is_always_equal::value&&
boost::is_nothrow_swappable<H>::value&&
boost::is_nothrow_swappable<P>::value)
{
@ -2146,7 +2140,7 @@ namespace boost {
// hash policy
template <class T, class H, class P, class A>
float unordered_multiset<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
float unordered_multiset<T, H, P, A>::load_factor() const noexcept
{
if (table_.size_ == 0) {
return 0.0f;
@ -2158,7 +2152,7 @@ namespace boost {
}
template <class T, class H, class P, class A>
void unordered_multiset<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
void unordered_multiset<T, H, P, A>::max_load_factor(float m) noexcept
{
table_.max_load_factor(m);
}
@ -2202,9 +2196,8 @@ namespace boost {
}
template <class T, class H, class P, class A>
inline void swap(
unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
inline void swap(unordered_multiset<T, H, P, A>& m1,
unordered_multiset<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
{
#if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
struct dummy
@ -2258,10 +2251,7 @@ namespace boost {
}
public:
BOOST_CONSTEXPR node_handle_set() BOOST_NOEXCEPT : ptr_(),
has_alloc_(false)
{
}
BOOST_CONSTEXPR node_handle_set() noexcept : ptr_(), has_alloc_(false) {}
~node_handle_set()
{
@ -2272,9 +2262,9 @@ namespace boost {
}
}
node_handle_set(BOOST_RV_REF(node_handle_set) n) BOOST_NOEXCEPT
: ptr_(n.ptr_),
alloc_(boost::move(n.alloc_))
node_handle_set(BOOST_RV_REF(node_handle_set) n) noexcept
: ptr_(n.ptr_),
alloc_(boost::move(n.alloc_))
{
n.ptr_ = node_pointer();
}
@ -2310,16 +2300,16 @@ namespace boost {
BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
bool operator!() const noexcept { return ptr_ ? 0 : 1; }
BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
{
return ptr_ ? 0 : 1;
}
void swap(node_handle_set& n) BOOST_NOEXCEPT_IF(
value_allocator_traits::propagate_on_container_swap::value ||
value_allocator_traits::is_always_equal::value)
void swap(node_handle_set& n)
noexcept(value_allocator_traits::propagate_on_container_swap::value ||
value_allocator_traits::is_always_equal::value)
{
BOOST_ASSERT(
!alloc_.has_value() || !n.alloc_.has_value() ||
@ -2335,7 +2325,7 @@ namespace boost {
template <typename N, typename T, typename A>
void swap(node_handle_set<N, T, A>& x, node_handle_set<N, T, A>& y)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
noexcept(noexcept(x.swap(y)))
{
x.swap(y);
}
@ -2356,10 +2346,10 @@ namespace boost {
insert_return_type_set() : position(), inserted(false), node() {}
insert_return_type_set(BOOST_RV_REF(insert_return_type_set)
x) BOOST_NOEXCEPT : position(x.position),
inserted(x.inserted),
node(boost::move(x.node))
insert_return_type_set(BOOST_RV_REF(insert_return_type_set) x) noexcept
: position(x.position),
inserted(x.inserted),
node(boost::move(x.node))
{
}
@ -2373,8 +2363,8 @@ namespace boost {
};
template <class Iter, class NodeType>
void swap(
insert_return_type_set<Iter, NodeType>& x, insert_return_type_set<Iter, NodeType>& y)
void swap(insert_return_type_set<Iter, NodeType>& x,
insert_return_type_set<Iter, NodeType>& y)
{
boost::core::invoke_swap(x.node, y.node);
boost::core::invoke_swap(x.inserted, y.inserted);

18
include/boost/unordered/unordered_set_fwd.hpp
View File

@ -29,9 +29,8 @@ namespace boost {
inline bool operator!=(
unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
template <class T, class H, class P, class A>
inline void swap(
unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
inline void swap(unordered_set<T, H, P, A>& m1,
unordered_set<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)));
template <class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type erase_if(
@ -48,9 +47,8 @@ namespace boost {
inline bool operator!=(unordered_multiset<T, H, P, A> const&,
unordered_multiset<T, H, P, A> const&);
template <class T, class H, class P, class A>
inline void swap(
unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
inline void swap(unordered_multiset<T, H, P, A>& m1,
unordered_multiset<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)));
template <class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type erase_if(
@ -58,13 +56,13 @@ namespace boost {
template <class N, class T, class A> class node_handle_set;
template <class Iter, class NodeType> struct insert_return_type_set;
}
} // namespace unordered
using boost::unordered::unordered_set;
using boost::unordered::unordered_multiset;
using boost::unordered::swap;
using boost::unordered::unordered_multiset;
using boost::unordered::unordered_set;
using boost::unordered::operator==;
using boost::unordered::operator!=;
}
} // namespace boost
#endif

2
test/unordered/compile_tests.hpp
View File

@ -46,7 +46,7 @@ template <class T> int implicit_construct()
#endif
#if !defined(BOOST_NO_CXX11_NOEXCEPT)
#define TEST_NOEXCEPT_EXPR(x) BOOST_STATIC_ASSERT((BOOST_NOEXCEPT_EXPR(x)));
#define TEST_NOEXCEPT_EXPR(x) BOOST_STATIC_ASSERT((noexcept(x)));
#else
#define TEST_NOEXCEPT_EXPR(x)
#endif

14
test/unordered/noexcept_tests.cpp
View File

@ -62,8 +62,7 @@ namespace noexcept_tests {
typedef boost::hash<int> base;
public:
hash_nothrow(BOOST_RV_REF(hash_nothrow))
BOOST_NOEXCEPT_IF(nothrow_move_construct)
hash_nothrow(BOOST_RV_REF(hash_nothrow)) noexcept(nothrow_move_construct)
{
if (!nothrow_move_construct) {
test_throw("Move Constructor");
@ -78,7 +77,7 @@ namespace noexcept_tests {
return *this;
}
hash_nothrow& operator=(BOOST_RV_REF(hash_nothrow))
BOOST_NOEXCEPT_IF(nothrow_move_assign)
noexcept(nothrow_move_assign)
{
if (!nothrow_move_assign) {
test_throw("Move Assign");
@ -90,8 +89,7 @@ namespace noexcept_tests {
test_throw("Operator");
return static_cast<base const&>(*this)(x);
}
friend void swap(hash_nothrow&, hash_nothrow&)
BOOST_NOEXCEPT_IF(nothrow_swap)
friend void swap(hash_nothrow&, hash_nothrow&) noexcept(nothrow_swap)
{
if (!nothrow_swap) {
test_throw("Swap");
@ -113,7 +111,7 @@ namespace noexcept_tests {
public:
equal_to_nothrow(BOOST_RV_REF(equal_to_nothrow))
BOOST_NOEXCEPT_IF(nothrow_move_construct)
noexcept(nothrow_move_construct)
{
if (!nothrow_move_construct) {
test_throw("Move Constructor");
@ -128,7 +126,7 @@ namespace noexcept_tests {
return *this;
}
equal_to_nothrow& operator=(BOOST_RV_REF(equal_to_nothrow))
BOOST_NOEXCEPT_IF(nothrow_move_assign)
noexcept(nothrow_move_assign)
{
if (!nothrow_move_assign) {
test_throw("Move Assign");
@ -141,7 +139,7 @@ namespace noexcept_tests {
return x == y;
}
friend void swap(equal_to_nothrow&, equal_to_nothrow&)
BOOST_NOEXCEPT_IF(nothrow_swap)
noexcept(nothrow_swap)
{
if (!nothrow_swap) {
test_throw("Swap");

4
test/unordered/reserve_tests.cpp
View File

@ -24,7 +24,7 @@ template <typename T> struct A
A() : i(++count) {}
template <class U> A(const A<U>& a) BOOST_NOEXCEPT : i(a.i) {}
template <class U> A(const A<U>& a) noexcept : i(a.i) {}
T* allocate(std::size_t n)
{
@ -33,7 +33,7 @@ template <typename T> struct A
return (T*)std::calloc(n, sizeof(T));
}
void deallocate(T* p, std::size_t n) BOOST_NOEXCEPT
void deallocate(T* p, std::size_t n) noexcept
{
total_allocation -= n * sizeof(T);
std::free(p);