168492376
/
gnss-sim
1
0
Fork 0
Code Issues 10 Pull Requests Packages Projects Releases Wiki Activity
gnss-sim/3rdparty/boost/unordered/detail/implementation.hpp

2913 lines
88 KiB
C++
Raw Normal View History

change boost and uhd lib version
2024-12-24 16:15:51 +00:00
// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
// Copyright (C) 2005-2016 Daniel James
// Copyright (C) 2022-2024 Joaquin M Lopez Munoz.
// Copyright (C) 2022-2023 Christian Mazakas
// Copyright (C) 2024 Braden Ganetsky
//
// 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)
#ifndef BOOST_UNORDERED_DETAIL_IMPLEMENTATION_HPP
#define BOOST_UNORDERED_DETAIL_IMPLEMENTATION_HPP
#include <boost/config.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
#pragma once
#endif
#include <boost/unordered/detail/allocator_constructed.hpp>
#include <boost/unordered/detail/fca.hpp>
#include <boost/unordered/detail/opt_storage.hpp>
#include <boost/unordered/detail/serialize_tracked_address.hpp>
#include <boost/unordered/detail/static_assert.hpp>
#include <boost/unordered/detail/type_traits.hpp>
#include <boost/assert.hpp>
#include <boost/core/allocator_traits.hpp>
#include <boost/core/bit.hpp>
#include <boost/core/invoke_swap.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/core/pointer_traits.hpp>
#include <boost/core/serialization.hpp>
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/throw_exception.hpp>
#include <algorithm>
#include <cmath>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <tuple> // std::forward_as_tuple
namespace boost {
namespace tuples {
struct null_type;
}
} // namespace boost
// BOOST_UNORDERED_SUPPRESS_DEPRECATED
//
// Define to stop deprecation attributes
#if defined(BOOST_UNORDERED_SUPPRESS_DEPRECATED)
#define BOOST_UNORDERED_DEPRECATED(msg)
#endif
// BOOST_UNORDERED_DEPRECATED
//
// Wrapper around various depreaction attributes.
#if defined(__has_cpp_attribute) && \
(!defined(__cplusplus) || __cplusplus >= 201402)
#if __has_cpp_attribute(deprecated) && !defined(BOOST_UNORDERED_DEPRECATED)
#define BOOST_UNORDERED_DEPRECATED(msg) [[deprecated(msg)]]
#endif
#endif
#if !defined(BOOST_UNORDERED_DEPRECATED)
#if defined(__GNUC__) && __GNUC__ >= 4
#define BOOST_UNORDERED_DEPRECATED(msg) __attribute__((deprecated))
#elif defined(_MSC_VER) && _MSC_VER >= 1400
#define BOOST_UNORDERED_DEPRECATED(msg) __declspec(deprecated(msg))
#elif defined(_MSC_VER) && _MSC_VER >= 1310
#define BOOST_UNORDERED_DEPRECATED(msg) __declspec(deprecated)
#else
#define BOOST_UNORDERED_DEPRECATED(msg)
#endif
#endif
namespace boost {
namespace unordered {
using std::piecewise_construct;
using std::piecewise_construct_t;
namespace detail {
template <typename Types> struct table;
static const float minimum_max_load_factor = 1e-3f;
static const std::size_t default_bucket_count = 0;
struct move_tag
{
};
struct empty_emplace
{
};
struct no_key
{
no_key() {}
template <class T> no_key(T const&) {}
};
struct converting_key
{
};
namespace func {
template <class T> inline void ignore_unused_variable_warning(T const&)
{
}
} // namespace func
//////////////////////////////////////////////////////////////////////////
// iterator SFINAE
template <typename I>
struct is_forward : std::is_base_of<std::forward_iterator_tag,
typename std::iterator_traits<I>::iterator_category>
{
};
template <typename I, typename ReturnType>
struct enable_if_forward
: std::enable_if<boost::unordered::detail::is_forward<I>::value,
ReturnType>
{
};
template <typename I, typename ReturnType>
struct disable_if_forward
: std::enable_if<!boost::unordered::detail::is_forward<I>::value,
ReturnType>
{
};
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
namespace detail {
//////////////////////////////////////////////////////////////////////////
// insert_size/initial_size
template <class I>
inline typename boost::unordered::detail::enable_if_forward<I,
std::size_t>::type
insert_size(I i, I j)
{
return static_cast<std::size_t>(std::distance(i, j));
}
template <class I>
inline typename boost::unordered::detail::disable_if_forward<I,
std::size_t>::type
insert_size(I, I)
{
return 1;
}
template <class I>
inline std::size_t initial_size(I i, I j,
std::size_t num_buckets =
boost::unordered::detail::default_bucket_count)
{
return (std::max)(
boost::unordered::detail::insert_size(i, j), num_buckets);
}
//////////////////////////////////////////////////////////////////////////
// compressed
template <typename T, int Index>
struct compressed_base : boost::empty_value<T>
{
compressed_base(T const& x) : empty_value<T>(boost::empty_init_t(), x)
{
}
compressed_base(T& x, move_tag)
: empty_value<T>(boost::empty_init_t(), std::move(x))
{
}
T& get() { return empty_value<T>::get(); }
T const& get() const { return empty_value<T>::get(); }
};
template <typename T, int Index>
struct generate_base : boost::unordered::detail::compressed_base<T, Index>
{
typedef compressed_base<T, Index> type;
generate_base() : type() {}
};
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
{
typedef typename generate_base<T1, 1>::type base1;
typedef typename generate_base<T2, 2>::type base2;
typedef T1 first_type;
typedef T2 second_type;
first_type& first() { return static_cast<base1*>(this)->get(); }
first_type const& first() const
{
return static_cast<base1 const*>(this)->get();
}
second_type& second() { return static_cast<base2*>(this)->get(); }
second_type const& second() const
{
return static_cast<base2 const*>(this)->get();
}
template <typename First, typename Second>
compressed(First const& x1, Second const& x2) : base1(x1), base2(x2)
{
}
compressed(compressed const& x) : base1(x.first()), base2(x.second()) {}
compressed(compressed& x, move_tag m)
: base1(x.first(), m), base2(x.second(), m)
{
}
void assign(compressed const& x)
{
first() = x.first();
second() = x.second();
}
void move_assign(compressed& x)
{
first() = std::move(x.first());
second() = std::move(x.second());
}
void swap(compressed& x)
{
boost::core::invoke_swap(first(), x.first());
boost::core::invoke_swap(second(), x.second());
}
private:
// Prevent assignment just to make use of assign or
// move_assign explicit.
compressed& operator=(compressed const&);
};
//////////////////////////////////////////////////////////////////////////
// pair_traits
//
// Used to get the types from a pair without instantiating it.
template <typename Pair> struct pair_traits
{
typedef typename Pair::first_type first_type;
typedef typename Pair::second_type second_type;
};
template <typename T1, typename T2> struct pair_traits<std::pair<T1, T2> >
{
typedef T1 first_type;
typedef T2 second_type;
};
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable : 4512) // assignment operator could not be generated.
#pragma warning(disable : 4345) // behavior change: an object of POD type
// constructed with an initializer of the form ()
// will be default-initialized.
#endif
//////////////////////////////////////////////////////////////////////////
// Bits and pieces for implementing traits
template <typename T> typename std::add_lvalue_reference<T>::type make();
struct choice2
{
typedef char (&type)[2];
};
struct choice1 : choice2
{
typedef char (&type)[1];
};
choice1 choose();
typedef choice1::type yes_type;
typedef choice2::type no_type;
struct private_type
{
private_type const& operator,(int) const;
};
template <typename T> no_type is_private_type(T const&);
yes_type is_private_type(private_type const&);
struct convert_from_anything
{
template <typename T> convert_from_anything(T const&);
};
} // namespace detail
} // namespace unordered
} // namespace boost
////////////////////////////////////////////////////////////////////////////////
//
// Some utilities for implementing allocator_traits, but useful elsewhere so
// they're always defined.
namespace boost {
namespace unordered {
namespace detail {
////////////////////////////////////////////////////////////////////////////
// Explicitly call a destructor
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable : 4100) // unreferenced formal parameter
#endif
namespace func {
template <class T> inline void destroy(T* x) { x->~T(); }
} // namespace func
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
//////////////////////////////////////////////////////////////////////////
// value_base
//
// Space used to store values.
template <typename ValueType> struct value_base
{
typedef ValueType value_type;
opt_storage<value_type> data_;
value_base() : data_() {}
void* address() { return this; }
value_type& value() { return *(ValueType*)this; }
value_type const& value() const { return *(ValueType const*)this; }
value_type* value_ptr() { return (ValueType*)this; }
value_type const* value_ptr() const { return (ValueType const*)this; }
private:
value_base& operator=(value_base const&);
};
//////////////////////////////////////////////////////////////////////////
// optional
// TODO: Use std::optional when available.
template <typename T> class optional
{
boost::unordered::detail::value_base<T> value_;
bool has_value_;
void destroy()
{
if (has_value_) {
boost::unordered::detail::func::destroy(value_.value_ptr());
has_value_ = false;
}
}
void move(optional<T>& x)
{
BOOST_ASSERT(!has_value_ && x.has_value_);
new (value_.value_ptr()) T(std::move(x.value_.value()));
boost::unordered::detail::func::destroy(x.value_.value_ptr());
has_value_ = true;
x.has_value_ = false;
}
public:
optional() noexcept : has_value_(false) {}
optional(optional const&) = delete;
optional& operator=(optional const&) = delete;
optional(optional<T>&& x) : has_value_(false)
{
if (x.has_value_) {
move(x);
}
}
explicit optional(T const& x) : has_value_(true)
{
new (value_.value_ptr()) T(x);
}
optional& operator=(optional<T>&& x)
{
destroy();
if (x.has_value_) {
move(x);
}
return *this;
}
~optional() { destroy(); }
bool has_value() const { return has_value_; }
T& operator*() { return value_.value(); }
T const& operator*() const { return value_.value(); }
T* operator->() { return value_.value_ptr(); }
T const* operator->() const { return value_.value_ptr(); }
bool operator==(optional<T> const& x) const
{
return has_value_ ? x.has_value_ && value_.value() == x.value_.value()
: !x.has_value_;
}
bool operator!=(optional<T> const& x) const { return !((*this) == x); }
void swap(optional<T>& x)
{
if (has_value_ != x.has_value_) {
if (has_value_) {
x.move(*this);
} else {
move(x);
}
} else if (has_value_) {
boost::core::invoke_swap(value_.value(), x.value_.value());
}
}
friend void swap(optional<T>& x, optional<T>& y) { x.swap(y); }
};
} // namespace detail
} // namespace unordered
} // namespace boost
////////////////////////////////////////////////////////////////////////////////
//
// Allocator traits
//
namespace boost {
namespace unordered {
namespace detail {
template <typename Alloc>
struct allocator_traits : boost::allocator_traits<Alloc>
{
};
template <typename Alloc, typename T>
struct rebind_wrap : boost::allocator_rebind<Alloc, T>
{
};
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
namespace detail {
namespace func {
////////////////////////////////////////////////////////////////////////
// Trait to check for piecewise construction.
template <typename A0> struct use_piecewise
{
static choice1::type test(choice1, std::piecewise_construct_t);
static choice2::type test(choice2, ...);
enum
{
value = sizeof(choice1::type) ==
sizeof(test(choose(), boost::unordered::detail::make<A0>()))
};
};
////////////////////////////////////////////////////////////////////////
// Construct from variadic parameters
template <typename Alloc, typename T, typename... Args>
inline void construct_from_args(
Alloc& alloc, T* address, Args&&... args)
{
boost::allocator_construct(
alloc, address, std::forward<Args>(args)...);
}
// For backwards compatibility, implement a special case for
// piecewise_construct with boost::tuple
template <typename A0> struct detect_std_tuple
{
template <class... Args>
static choice1::type test(choice1, std::tuple<Args...> const&);
static choice2::type test(choice2, ...);
enum
{
value = sizeof(choice1::type) ==
sizeof(test(choose(), boost::unordered::detail::make<A0>()))
};
};
// Special case for piecewise_construct
template <template <class...> class Tuple, class... Args,
std::size_t... Is, class... TupleArgs>
std::tuple<typename std::add_lvalue_reference<Args>::type...>
to_std_tuple_impl(boost::mp11::mp_list<Args...>,
Tuple<TupleArgs...>& tuple, boost::mp11::index_sequence<Is...>)
{
(void)tuple;
using std::get;
return std::tuple<typename std::add_lvalue_reference<Args>::type...>(
get<Is>(tuple)...);
}
template <class T>
using add_lvalue_reference_t =
typename std::add_lvalue_reference<T>::type;
template <template <class...> class Tuple, class... Args>
boost::mp11::mp_transform<add_lvalue_reference_t,
boost::mp11::mp_remove<std::tuple<Args...>,
boost::tuples::null_type> >
to_std_tuple(Tuple<Args...>& tuple)
{
using list = boost::mp11::mp_remove<boost::mp11::mp_list<Args...>,
boost::tuples::null_type>;
using list_size = boost::mp11::mp_size<list>;
using index_seq = boost::mp11::make_index_sequence<list_size::value>;
return to_std_tuple_impl(list{}, tuple, index_seq{});
}
template <typename Alloc, typename A, typename B, typename A0,
typename A1, typename A2>
inline typename std::enable_if<use_piecewise<A0>::value &&
!detect_std_tuple<A1>::value &&
!detect_std_tuple<A2>::value,
void>::type
construct_from_args(
Alloc& alloc, std::pair<A, B>* address, A0&&, A1&& a1, A2&& a2)
{
boost::allocator_construct(alloc, address, std::piecewise_construct,
to_std_tuple(a1), to_std_tuple(a2));
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
namespace detail {
///////////////////////////////////////////////////////////////////
//
// Node construction
template <typename NodeAlloc> struct node_constructor
{
typedef NodeAlloc node_allocator;
typedef boost::unordered::detail::allocator_traits<NodeAlloc>
node_allocator_traits;
typedef typename node_allocator_traits::value_type node;
typedef typename node_allocator_traits::pointer node_pointer;
typedef typename node::value_type value_type;
node_allocator& alloc_;
node_pointer node_;
node_constructor(node_allocator& n) : alloc_(n), node_() {}
~node_constructor();
void create_node();
// no throw
node_pointer release()
{
BOOST_ASSERT(node_);
node_pointer p = node_;
node_ = node_pointer();
return p;
}
private:
node_constructor(node_constructor const&);
node_constructor& operator=(node_constructor const&);
};
template <typename Alloc> node_constructor<Alloc>::~node_constructor()
{
if (node_) {
boost::unordered::detail::func::destroy(boost::to_address(node_));
node_allocator_traits::deallocate(alloc_, node_, 1);
}
}
template <typename Alloc> void node_constructor<Alloc>::create_node()
{
BOOST_ASSERT(!node_);
node_ = node_allocator_traits::allocate(alloc_, 1);
new ((void*)boost::to_address(node_)) node();
}
template <typename NodeAlloc> struct node_tmp
{
typedef typename boost::allocator_value_type<NodeAlloc>::type node;
typedef typename boost::allocator_pointer<NodeAlloc>::type node_pointer;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<NodeAlloc, value_type>::type
value_allocator;
NodeAlloc& alloc_;
node_pointer node_;
explicit node_tmp(node_pointer n, NodeAlloc& a) : alloc_(a), node_(n) {}
~node_tmp();
// no throw
node_pointer release()
{
node_pointer p = node_;
node_ = node_pointer();
return p;
}
};
template <typename Alloc> node_tmp<Alloc>::~node_tmp()
{
if (node_) {
value_allocator val_alloc(alloc_);
boost::allocator_destroy(val_alloc, node_->value_ptr());
boost::allocator_deallocate(alloc_, node_, 1);
}
}
} // namespace detail
} // namespace unordered
} // namespace boost
namespace boost {
namespace unordered {
namespace detail {
namespace func {
// Some nicer construct_node functions, might try to
// improve implementation later.
template <typename Alloc, typename... Args>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_from_args(Alloc& alloc, Args&&... args)
{
typedef typename boost::allocator_value_type<Alloc>::type node;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<Alloc, value_type>::type
value_allocator;
value_allocator val_alloc(alloc);
node_constructor<Alloc> a(alloc);
a.create_node();
construct_from_args(
val_alloc, a.node_->value_ptr(), std::forward<Args>(args)...);
return a.release();
}
template <typename Alloc, typename U>
inline typename boost::allocator_pointer<Alloc>::type construct_node(
Alloc& alloc, U&& x)
{
node_constructor<Alloc> a(alloc);
a.create_node();
typedef typename boost::allocator_value_type<Alloc>::type node;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<Alloc, value_type>::type
value_allocator;
value_allocator val_alloc(alloc);
boost::allocator_construct(
val_alloc, a.node_->value_ptr(), std::forward<U>(x));
return a.release();
}
template <typename Alloc, typename Key>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_pair(Alloc& alloc, Key&& k)
{
node_constructor<Alloc> a(alloc);
a.create_node();
typedef typename boost::allocator_value_type<Alloc>::type node;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<Alloc, value_type>::type
value_allocator;
value_allocator val_alloc(alloc);
boost::allocator_construct(val_alloc, a.node_->value_ptr(),
std::piecewise_construct,
std::forward_as_tuple(std::forward<Key>(k)),
std::forward_as_tuple());
return a.release();
}
template <typename Alloc, typename Key, typename Mapped>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_pair(Alloc& alloc, Key&& k, Mapped&& m)
{
node_constructor<Alloc> a(alloc);
a.create_node();
typedef typename boost::allocator_value_type<Alloc>::type node;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<Alloc, value_type>::type
value_allocator;
value_allocator val_alloc(alloc);
boost::allocator_construct(val_alloc, a.node_->value_ptr(),
std::piecewise_construct,
std::forward_as_tuple(std::forward<Key>(k)),
std::forward_as_tuple(std::forward<Mapped>(m)));
return a.release();
}
template <typename Alloc, typename Key, typename... Args>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_pair_from_args(Alloc& alloc, Key&& k, Args&&... args)
{
node_constructor<Alloc> a(alloc);
a.create_node();
typedef typename boost::allocator_value_type<Alloc>::type node;
typedef typename node::value_type value_type;
typedef typename boost::allocator_rebind<Alloc, value_type>::type
value_allocator;
value_allocator val_alloc(alloc);
boost::allocator_construct(val_alloc, a.node_->value_ptr(),
std::piecewise_construct,
std::forward_as_tuple(std::forward<Key>(k)),
std::forward_as_tuple(std::forward<Args>(args)...));
return a.release();
}
template <typename T, typename Alloc, typename Key>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_from_key(T*, Alloc& alloc, Key&& k)
{
return construct_node(alloc, std::forward<Key>(k));
}
template <typename T, typename V, typename Alloc, typename Key>
inline typename boost::allocator_pointer<Alloc>::type
construct_node_from_key(std::pair<T const, V>*, Alloc& alloc, Key&& k)
{
return construct_node_pair(alloc, std::forward<Key>(k));
}
} // namespace func
} // namespace detail
} // namespace unordered
} // namespace boost
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
namespace boost {
namespace unordered {
namespace detail {
//////////////////////////////////////////////////////////////////////////
// Functions
//
// This double buffers the storage for the hash function and key equality
// predicate in order to have exception safe copy/swap. To do so,
// use 'construct_spare' to construct in the spare space, and then when
// ready to use 'switch_functions' to switch to the new functions.
// If an exception is thrown between these two calls, use
// 'cleanup_spare_functions' to destroy the unused constructed functions.
#if defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER)
// gcc-12 warns when accessing the `current_functions` of our `functions`
// class below with `-Wmaybe-unitialized`. By laundering the pointer, we
// silence the warning and assure the compiler that a valid object exists
// 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) noexcept
{
return __builtin_launder(p);
}
#else
template <class T> T* launder(T* p) noexcept { return p; }
#endif
template <class H, class P> class functions
{
public:
static const bool nothrow_move_assignable =
std::is_nothrow_move_assignable<H>::value &&
std::is_nothrow_move_assignable<P>::value;
static const bool nothrow_move_constructible =
std::is_nothrow_move_constructible<H>::value &&
std::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;
private:
functions& operator=(functions const&);
typedef compressed<H, P> function_pair;
unsigned char current_; // 0/1 - Currently active functions
// +2 - Both constructed
opt_storage<function_pair> funcs_[2];
public:
functions(H const& hf, P const& eq) : current_(0)
{
construct_functions(current_, hf, eq);
}
functions(functions const& bf) : current_(0)
{
construct_functions(current_, bf.current_functions());
}
functions(functions& bf, boost::unordered::detail::move_tag)
: current_(0)
{
construct_functions(current_, bf.current_functions(),
std::integral_constant<bool, nothrow_move_constructible>());
}
~functions()
{
BOOST_ASSERT(!(current_ & 2));
destroy_functions(current_);
}
H const& hash_function() const { return current_functions().first(); }
P const& key_eq() const { return current_functions().second(); }
function_pair const& current_functions() const
{
return *::boost::unordered::detail::launder(
static_cast<function_pair const*>(
static_cast<void const*>(funcs_[current_ & 1].address())));
}
function_pair& current_functions()
{
return *::boost::unordered::detail::launder(
static_cast<function_pair*>(
static_cast<void*>(funcs_[current_ & 1].address())));
}
void construct_spare_functions(function_pair const& f)
{
BOOST_ASSERT(!(current_ & 2));
construct_functions(current_ ^ 1, f);
current_ |= 2;
}
void cleanup_spare_functions()
{
if (current_ & 2) {
current_ = static_cast<unsigned char>(current_ & 1);
destroy_functions(current_ ^ 1);
}
}
void switch_functions()
{
BOOST_ASSERT(current_ & 2);
destroy_functions(static_cast<unsigned char>(current_ & 1));
current_ ^= 3;
}
private:
void construct_functions(unsigned char which, H const& hf, P const& eq)
{
BOOST_ASSERT(!(which & 2));
new ((void*)&funcs_[which]) function_pair(hf, eq);
}
void construct_functions(
unsigned char which, function_pair const& f, std::false_type = {})
{
BOOST_ASSERT(!(which & 2));
new ((void*)&funcs_[which]) function_pair(f);
}
void construct_functions(
unsigned char which, function_pair& f, std::true_type)
{
BOOST_ASSERT(!(which & 2));
new ((void*)&funcs_[which])
function_pair(f, boost::unordered::detail::move_tag());
}
void destroy_functions(unsigned char which)
{
BOOST_ASSERT(!(which & 2));
boost::unordered::detail::func::destroy(
(function_pair*)(&funcs_[which]));
}
};
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
//////////////////////////////////////////////////////////////////////////
// convert double to std::size_t
inline std::size_t double_to_size(double f)
{
return f >= static_cast<double>(
(std::numeric_limits<std::size_t>::max)())
? (std::numeric_limits<std::size_t>::max)()
: static_cast<std::size_t>(f);
}
//////////////////////////////////////////////////////////////////////////
// iterator definitions
namespace iterator_detail {
template <class Node, class Bucket> class c_iterator;
template <class Node, class Bucket> class iterator
{
public:
typedef typename Node::value_type value_type;
typedef value_type element_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
iterator() : p(), itb() {}
reference operator*() const noexcept { return dereference(); }
pointer operator->() const noexcept
{
pointer x = std::addressof(p->value());
return x;
}
iterator& operator++() noexcept
{
increment();
return *this;
}
iterator operator++(int) noexcept
{
iterator old = *this;
increment();
return old;
}
bool operator==(iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(iterator const& other) const noexcept
{
return !equal(other);
}
bool operator==(
boost::unordered::detail::iterator_detail::c_iterator<Node,
Bucket> const& other) const noexcept
{
return equal(other);
}
bool operator!=(
boost::unordered::detail::iterator_detail::c_iterator<Node,
Bucket> const& other) const noexcept
{
return !equal(other);
}
private:
typedef typename Node::node_pointer node_pointer;
typedef grouped_bucket_iterator<Bucket> bucket_iterator;
node_pointer p;
bucket_iterator itb;
template <class Types> friend struct boost::unordered::detail::table;
template <class N, class B> friend class c_iterator;
iterator(node_pointer p_, bucket_iterator itb_) : p(p_), itb(itb_) {}
value_type& dereference() const noexcept { return p->value(); }
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 noexcept
{
return (p == x.p);
}
void increment() noexcept
{
p = p->next;
if (!p) {
p = (++itb)->next;
}
}
template <typename Archive>
friend void serialization_track(Archive& ar, const iterator& x)
{
if (x.p) {
track_address(ar, x.p);
serialization_track(ar, x.itb);
}
}
friend class boost::serialization::access;
template <typename Archive> void serialize(Archive& ar, unsigned int)
{
if (!p)
itb = bucket_iterator();
serialize_tracked_address(ar, p);
ar& core::make_nvp("bucket_iterator", itb);
}
};
template <class Node, class Bucket> class c_iterator
{
public:
typedef typename Node::value_type value_type;
typedef value_type const element_type;
typedef value_type const* pointer;
typedef value_type const& reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
c_iterator() : p(), itb() {}
c_iterator(iterator<Node, Bucket> it) : p(it.p), itb(it.itb) {}
reference operator*() const noexcept { return dereference(); }
pointer operator->() const noexcept
{
pointer x = std::addressof(p->value());
return x;
}
c_iterator& operator++() noexcept
{
increment();
return *this;
}
c_iterator operator++(int) noexcept
{
c_iterator old = *this;
increment();
return old;
}
bool operator==(c_iterator const& other) const noexcept
{
return equal(other);
}
bool operator!=(c_iterator const& other) const noexcept
{
return !equal(other);
}
bool operator==(
boost::unordered::detail::iterator_detail::iterator<Node,
Bucket> const& other) const noexcept
{
return equal(other);
}
bool operator!=(
boost::unordered::detail::iterator_detail::iterator<Node,
Bucket> const& other) const noexcept
{
return !equal(other);
}
private:
typedef typename Node::node_pointer node_pointer;
typedef grouped_bucket_iterator<Bucket> bucket_iterator;
node_pointer p;
bucket_iterator itb;
template <class Types> friend struct boost::unordered::detail::table;
template <class, class> friend class iterator;
c_iterator(node_pointer p_, bucket_iterator itb_) : p(p_), itb(itb_)
{
}
value_type const& dereference() const noexcept { return p->value(); }
bool equal(const c_iterator& x) const noexcept { return (p == x.p); }
void increment() noexcept
{
p = p->next;
if (!p) {
p = (++itb)->next;
}
}
template <typename Archive>
friend void serialization_track(Archive& ar, const c_iterator& x)
{
if (x.p) {
track_address(ar, x.p);
serialization_track(ar, x.itb);
}
}
friend class boost::serialization::access;
template <typename Archive> void serialize(Archive& ar, unsigned int)
{
if (!p)
itb = bucket_iterator();
serialize_tracked_address(ar, p);
ar& core::make_nvp("bucket_iterator", itb);
}
};
} // namespace iterator_detail
//////////////////////////////////////////////////////////////////////////
// table structure used by the containers
template <typename Types>
struct table : boost::unordered::detail::functions<typename Types::hasher,
typename Types::key_equal>
{
private:
table(table const&);
table& operator=(table const&);
public:
typedef typename Types::hasher hasher;
typedef typename Types::key_equal key_equal;
typedef typename Types::const_key_type const_key_type;
typedef typename Types::extractor extractor;
typedef typename Types::value_type value_type;
typedef typename Types::table table_impl;
typedef boost::unordered::detail::functions<typename Types::hasher,
typename Types::key_equal>
functions;
typedef typename Types::value_allocator value_allocator;
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 boost::unordered::detail::node_constructor<node_allocator_type>
node_constructor;
typedef boost::unordered::detail::node_tmp<node_allocator_type>
node_tmp;
typedef typename bucket_array_type::bucket_type bucket_type;
typedef typename bucket_array_type::iterator bucket_iterator;
typedef typename bucket_array_type::local_iterator l_iterator;
typedef typename bucket_array_type::const_local_iterator cl_iterator;
typedef std::size_t size_type;
typedef iterator_detail::iterator<node_type, bucket_type> iterator;
typedef iterator_detail::c_iterator<node_type, bucket_type> c_iterator;
typedef std::pair<iterator, bool> emplace_return;
////////////////////////////////////////////////////////////////////////
// Members
std::size_t size_;
float mlf_;
std::size_t max_load_;
bucket_array_type buckets_;
public:
////////////////////////////////////////////////////////////////////////
// Data access
size_type bucket_count() const { return buckets_.bucket_count(); }
template <class Key>
iterator next_group(Key const& k, c_iterator n) const
{
c_iterator last = this->end();
while (n != last && this->key_eq()(k, extractor::extract(*n))) {
++n;
}
return iterator(n.p, n.itb);
}
template <class Key> std::size_t group_count(Key const& k) const
{
if (size_ == 0) {
return 0;
}
std::size_t c = 0;
std::size_t const key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
bool found = false;
for (node_pointer pos = itb->next; pos; pos = pos->next) {
if (this->key_eq()(k, this->get_key(pos))) {
++c;
found = true;
} else if (found) {
break;
}
}
return c;
}
node_allocator_type const& node_alloc() const
{
return buckets_.get_node_allocator();
}
node_allocator_type& node_alloc()
{
return buckets_.get_node_allocator();
}
std::size_t max_bucket_count() const
{
typedef typename bucket_array_type::size_policy size_policy;
return size_policy::size(size_policy::size_index(
boost::allocator_max_size(this->node_alloc())));
}
iterator begin() const
{
if (size_ == 0) {
return end();
}
bucket_iterator itb = buckets_.begin();
return iterator(itb->next, itb);
}
iterator end() const { return iterator(); }
l_iterator begin(std::size_t bucket_index) const
{
return buckets_.begin(bucket_index);
}
std::size_t hash_to_bucket(std::size_t hash_value) const
{
return buckets_.position(hash_value);
}
std::size_t bucket_size(std::size_t index) const
{
std::size_t count = 0;
if (size_ > 0) {
bucket_iterator itb = buckets_.at(index);
node_pointer n = itb->next;
while (n) {
++count;
n = n->next;
}
}
return count;
}
////////////////////////////////////////////////////////////////////////
// Load methods
void recalculate_max_load()
{
// From 6.3.1/13:
// Only resize when size >= mlf_ * count
std::size_t const bc = buckets_.bucket_count();
// it's important we do the `bc == 0` check here because the `mlf_`
// can be specified to be infinity. The operation `n * INF` is `INF`
// for all `n > 0` but NaN for `n == 0`.
//
max_load_ =
bc == 0 ? 0
: boost::unordered::detail::double_to_size(
static_cast<double>(mlf_) * static_cast<double>(bc));
}
void max_load_factor(float z)
{
BOOST_ASSERT(z > 0);
mlf_ = (std::max)(z, minimum_max_load_factor);
recalculate_max_load();
}
////////////////////////////////////////////////////////////////////////
// Constructors
table()
: functions(hasher(), key_equal()), size_(0), mlf_(1.0f),
max_load_(0)
{
}
table(std::size_t num_buckets, hasher const& hf, key_equal const& eq,
value_allocator const& a)
: functions(hf, eq), size_(0), mlf_(1.0f), max_load_(0),
buckets_(num_buckets, a)
{
recalculate_max_load();
}
table(table const& x, value_allocator const& a)
: functions(x), size_(0), mlf_(x.mlf_), max_load_(0),
buckets_(x.size_, a)
{
recalculate_max_load();
}
table(table& x, boost::unordered::detail::move_tag m)
: functions(x, m), size_(x.size_), mlf_(x.mlf_),
max_load_(x.max_load_), buckets_(std::move(x.buckets_))
{
x.size_ = 0;
x.max_load_ = 0;
}
table(table& x, value_allocator const& a,
boost::unordered::detail::move_tag m)
: functions(x, m), size_(0), mlf_(x.mlf_), max_load_(0),
buckets_(x.bucket_count(), a)
{
recalculate_max_load();
}
////////////////////////////////////////////////////////////////////////
// Swap and Move
void swap_allocators(table& other, std::false_type)
{
boost::unordered::detail::func::ignore_unused_variable_warning(other);
// According to 23.2.1.8, if propagate_on_container_swap is
// false the behaviour is undefined unless the allocators
// are equal.
BOOST_ASSERT(node_alloc() == other.node_alloc());
}
// Not nothrow swappable
void swap(table& x, std::false_type)
{
if (this == &x) {
return;
}
this->construct_spare_functions(x.current_functions());
BOOST_TRY { x.construct_spare_functions(this->current_functions()); }
BOOST_CATCH(...)
{
this->cleanup_spare_functions();
BOOST_RETHROW
}
BOOST_CATCH_END
this->switch_functions();
x.switch_functions();
buckets_.swap(x.buckets_);
boost::core::invoke_swap(size_, x.size_);
std::swap(mlf_, x.mlf_);
std::swap(max_load_, x.max_load_);
}
// Nothrow swappable
void swap(table& x, std::true_type)
{
buckets_.swap(x.buckets_);
boost::core::invoke_swap(size_, x.size_);
std::swap(mlf_, x.mlf_);
std::swap(max_load_, x.max_load_);
this->current_functions().swap(x.current_functions());
}
// Only swaps the allocators if propagate_on_container_swap.
// If not propagate_on_container_swap and allocators aren't
// equal, behaviour is undefined.
void swap(table& x)
{
BOOST_ASSERT(boost::allocator_propagate_on_container_swap<
node_allocator_type>::type::value ||
node_alloc() == x.node_alloc());
swap(x, std::integral_constant<bool, functions::nothrow_swappable>());
}
// Only call with nodes allocated with the currect allocator, or
// one that is equal to it. (Can't assert because other's
// allocators might have already been moved).
void move_buckets_from(table& other)
{
buckets_ = std::move(other.buckets_);
size_ = other.size_;
max_load_ = other.max_load_;
other.size_ = 0;
other.max_load_ = 0;
}
// For use in the constructor when allocators might be different.
void move_construct_buckets(table& src)
{
if (this->node_alloc() == src.node_alloc()) {
move_buckets_from(src);
return;
}
if (src.size_ == 0) {
return;
}
BOOST_ASSERT(buckets_.bucket_count() == src.buckets_.bucket_count());
this->reserve(src.size_);
for (iterator pos = src.begin(); pos != src.end(); ++pos) {
node_tmp b(detail::func::construct_node(
this->node_alloc(), std::move(pos.p->value())),
this->node_alloc());
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));
buckets_.insert_node(itb, b.release());
++size_;
}
}
////////////////////////////////////////////////////////////////////////
// Delete/destruct
~table() { delete_buckets(); }
void delete_node(node_pointer p)
{
node_allocator_type alloc = this->node_alloc();
value_allocator val_alloc(alloc);
boost::allocator_destroy(val_alloc, p->value_ptr());
boost::unordered::detail::func::destroy(boost::to_address(p));
boost::allocator_deallocate(alloc, p, 1);
}
void delete_buckets()
{
iterator pos = begin(), last = this->end();
for (; pos != last;) {
node_pointer p = pos.p;
bucket_iterator itb = pos.itb;
++pos;
buckets_.extract_node(itb, p);
delete_node(p);
--size_;
}
buckets_.clear();
}
////////////////////////////////////////////////////////////////////////
// Clear
void clear_impl();
////////////////////////////////////////////////////////////////////////
// Assignment
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;
if (this != &x) {
assign(x, is_unique, std::integral_constant<bool, pocca::value>());
}
}
template <typename UniqueType>
void assign(table const& x, UniqueType is_unique, std::false_type)
{
// Strong exception safety.
this->construct_spare_functions(x.current_functions());
BOOST_TRY
{
mlf_ = x.mlf_;
recalculate_max_load();
this->reserve_for_insert(x.size_);
this->clear_impl();
}
BOOST_CATCH(...)
{
this->cleanup_spare_functions();
BOOST_RETHROW
}
BOOST_CATCH_END
this->switch_functions();
copy_buckets(x, is_unique);
}
template <typename UniqueType>
void assign(table const& x, UniqueType is_unique, std::true_type)
{
if (node_alloc() == x.node_alloc()) {
buckets_.reset_allocator(x.node_alloc());
assign(x, is_unique, std::false_type());
} else {
bucket_array_type new_buckets(x.size_, x.node_alloc());
this->construct_spare_functions(x.current_functions());
this->switch_functions();
// Delete everything with current allocators before assigning
// the new ones.
delete_buckets();
buckets_.reset_allocator(x.node_alloc());
buckets_ = std::move(new_buckets);
// Copy over other data, all no throw.
mlf_ = x.mlf_;
reserve(x.size_);
// Finally copy the elements.
if (x.size_) {
copy_buckets(x, is_unique);
}
}
}
template <typename UniqueType>
void move_assign(table& x, UniqueType is_unique)
{
if (this != &x) {
move_assign(x, is_unique,
std::integral_constant<bool,
boost::allocator_propagate_on_container_move_assignment<
node_allocator_type>::type::value>());
}
}
// Propagate allocator
template <typename UniqueType>
void move_assign(table& x, UniqueType, std::true_type)
{
if (!functions::nothrow_move_assignable) {
this->construct_spare_functions(x.current_functions());
this->switch_functions();
} else {
this->current_functions().move_assign(x.current_functions());
}
delete_buckets();
buckets_.reset_allocator(x.buckets_.get_node_allocator());
mlf_ = x.mlf_;
move_buckets_from(x);
}
// Don't propagate allocator
template <typename UniqueType>
void move_assign(table& x, UniqueType is_unique, std::false_type)
{
if (node_alloc() == x.node_alloc()) {
move_assign_equal_alloc(x);
} else {
move_assign_realloc(x, is_unique);
}
}
void move_assign_equal_alloc(table& x)
{
if (!functions::nothrow_move_assignable) {
this->construct_spare_functions(x.current_functions());
this->switch_functions();
} else {
this->current_functions().move_assign(x.current_functions());
}
delete_buckets();
mlf_ = x.mlf_;
move_buckets_from(x);
}
template <typename UniqueType>
void move_assign_realloc(table& x, UniqueType is_unique)
{
this->construct_spare_functions(x.current_functions());
BOOST_TRY
{
mlf_ = x.mlf_;
recalculate_max_load();
if (x.size_ > 0) {
this->reserve_for_insert(x.size_);
}
this->clear_impl();
}
BOOST_CATCH(...)
{
this->cleanup_spare_functions();
BOOST_RETHROW
}
BOOST_CATCH_END
this->switch_functions();
move_assign_buckets(x, is_unique);
}
// Accessors
const_key_type& get_key(node_pointer n) const
{
return extractor::extract(n->value());
}
template <class Key> std::size_t hash(Key const& k) const
{
return this->hash_function()(k);
}
// Find Node
template <class Key>
node_pointer find_node_impl(Key const& x, bucket_iterator itb) const
{
node_pointer p = node_pointer();
if (itb != buckets_.end()) {
key_equal const& pred = this->key_eq();
p = itb->next;
for (; p; p = p->next) {
if (pred(x, extractor::extract(p->value()))) {
break;
}
}
}
return p;
}
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)));
}
node_pointer find_node(const_key_type& k, bucket_iterator itb) const
{
return find_node_impl(k, itb);
}
template <class Key> iterator find(Key const& k) const
{
return this->transparent_find(
k, this->hash_function(), this->key_eq());
}
template <class Key, class Hash, class Pred>
inline iterator transparent_find(
Key const& k, Hash const& h, Pred const& pred) const
{
if (size_ > 0) {
std::size_t const key_hash = h(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
for (node_pointer p = itb->next; p; p = p->next) {
if (BOOST_LIKELY(pred(k, extractor::extract(p->value())))) {
return iterator(p, itb);
}
}
}
return this->end();
}
template <class Key>
node_pointer* find_prev(Key const& key, bucket_iterator itb)
{
if (size_ > 0) {
key_equal pred = this->key_eq();
for (node_pointer* pp = std::addressof(itb->next); *pp;
pp = std::addressof((*pp)->next)) {
if (pred(key, extractor::extract((*pp)->value()))) {
return pp;
}
}
}
typedef node_pointer* node_pointer_pointer;
return node_pointer_pointer();
}
// Extract and erase
template <class Key> node_pointer extract_by_key_impl(Key const& k)
{
iterator it = this->find(k);
if (it == this->end()) {
return node_pointer();
}
buckets_.extract_node(it.itb, it.p);
--size_;
return it.p;
}
// Reserve and rehash
void transfer_node(
node_pointer p, bucket_type&, bucket_array_type& new_buckets)
{
const_key_type& key = extractor::extract(p->value());
std::size_t const h = this->hash(key);
bucket_iterator itnewb = new_buckets.at(new_buckets.position(h));
new_buckets.insert_node(itnewb, p);
}
static std::size_t min_buckets(std::size_t num_elements, float mlf)
{
std::size_t num_buckets = static_cast<std::size_t>(
std::ceil(static_cast<float>(num_elements) / mlf));
if (num_buckets == 0 && num_elements > 0) { // mlf == inf
num_buckets = 1;
}
return num_buckets;
}
void rehash(std::size_t);
void reserve(std::size_t);
void reserve_for_insert(std::size_t);
void rehash_impl(std::size_t);
////////////////////////////////////////////////////////////////////////
// Unique keys
// equals
bool equals_unique(table const& other) const
{
if (this->size_ != other.size_)
return false;
c_iterator pos = this->begin();
c_iterator last = this->end();
while (pos != last) {
node_pointer p = pos.p;
node_pointer p2 = other.find_node(this->get_key(p));
if (!p2 || !(p->value() == p2->value())) {
return false;
}
++pos;
}
return true;
}
// Emplace/Insert
template <typename... Args>
iterator emplace_hint_unique(
c_iterator hint, const_key_type& k, Args&&... args)
{
if (hint.p && this->key_eq()(k, this->get_key(hint.p))) {
return iterator(hint.p, hint.itb);
} else {
return emplace_unique(k, std::forward<Args>(args)...).first;
}
}
template <typename... Args>
emplace_return emplace_unique(const_key_type& k, Args&&... args)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
return emplace_return(iterator(pos, itb), false);
} else {
node_tmp b(boost::unordered::detail::func::construct_node_from_args(
this->node_alloc(), std::forward<Args>(args)...),
this->node_alloc());
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
node_pointer p = b.release();
buckets_.insert_node(itb, p);
++size_;
return emplace_return(iterator(p, itb), true);
}
}
template <typename... Args>
iterator emplace_hint_unique(c_iterator hint, no_key, Args&&... args)
{
node_tmp b(boost::unordered::detail::func::construct_node_from_args(
this->node_alloc(), std::forward<Args>(args)...),
this->node_alloc());
const_key_type& k = this->get_key(b.node_);
if (hint.p && this->key_eq()(k, this->get_key(hint.p))) {
return iterator(hint.p, hint.itb);
}
std::size_t const key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
return iterator(p, itb);
}
if (size_ + 1 > max_load_) {
this->reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
p = b.release();
buckets_.insert_node(itb, p);
++size_;
return iterator(p, itb);
}
template <typename... Args>
emplace_return emplace_unique(no_key, Args&&... args)
{
node_tmp b(boost::unordered::detail::func::construct_node_from_args(
this->node_alloc(), std::forward<Args>(args)...),
this->node_alloc());
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));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
return emplace_return(iterator(pos, itb), false);
} else {
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
node_pointer p = b.release();
buckets_.insert_node(itb, p);
++size_;
return emplace_return(iterator(p, itb), true);
}
}
template <typename K, typename V>
emplace_return emplace_unique(converting_key, K&& k, V&& v)
{
using alloc_cted = allocator_constructed<node_allocator_type,
typename Types::key_type>;
alloc_cted key(this->node_alloc(), std::forward<K>(k));
return emplace_unique(
key.value(), std::move(key.value()), std::forward<V>(v));
}
template <typename Key> emplace_return try_emplace_unique(Key&& k)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
return emplace_return(iterator(pos, itb), false);
} else {
node_allocator_type alloc = node_alloc();
value_type* dispatch = BOOST_NULLPTR;
node_tmp tmp(detail::func::construct_node_from_key(
dispatch, alloc, std::forward<Key>(k)),
alloc);
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
node_pointer p = tmp.release();
buckets_.insert_node(itb, p);
++size_;
return emplace_return(iterator(p, itb), true);
}
}
template <typename Key>
iterator try_emplace_hint_unique(c_iterator hint, Key&& k)
{
if (hint.p && this->key_eq()(extractor::extract(*hint), k)) {
return iterator(hint.p, hint.itb);
} else {
return try_emplace_unique(k).first;
}
}
template <typename Key, typename... Args>
emplace_return try_emplace_unique(Key&& k, Args&&... args)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer pos = this->find_node_impl(k, itb);
if (pos) {
return emplace_return(iterator(pos, itb), false);
}
node_tmp b(
boost::unordered::detail::func::construct_node_pair_from_args(
this->node_alloc(), k, std::forward<Args>(args)...),
this->node_alloc());
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
pos = b.release();
buckets_.insert_node(itb, pos);
++size_;
return emplace_return(iterator(pos, itb), true);
}
template <typename Key, typename... Args>
iterator try_emplace_hint_unique(
c_iterator hint, Key&& k, Args&&... args)
{
if (hint.p && this->key_eq()(hint->first, k)) {
return iterator(hint.p, hint.itb);
} else {
return try_emplace_unique(k, std::forward<Args>(args)...).first;
}
}
template <typename Key, typename M>
emplace_return insert_or_assign_unique(Key&& k, M&& obj)
{
std::size_t key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
p->value().second = std::forward<M>(obj);
return emplace_return(iterator(p, itb), false);
}
node_tmp b(
boost::unordered::detail::func::construct_node_pair(
this->node_alloc(), std::forward<Key>(k), std::forward<M>(obj)),
node_alloc());
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
p = b.release();
buckets_.insert_node(itb, p);
++size_;
return emplace_return(iterator(p, itb), true);
}
template <typename NodeType, typename InsertReturnType>
void move_insert_node_type_unique(
NodeType& np, InsertReturnType& result)
{
if (!np) {
result.position = this->end();
result.inserted = false;
return;
}
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));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
iterator pos(p, itb);
result.node = std::move(np);
result.position = pos;
result.inserted = false;
return;
}
this->reserve_for_insert(size_ + 1);
p = np.ptr_;
itb = buckets_.at(buckets_.position(key_hash));
buckets_.insert_node(itb, p);
np.ptr_ = node_pointer();
++size_;
result.position = iterator(p, itb);
result.inserted = true;
}
template <typename NodeType>
iterator move_insert_node_type_with_hint_unique(
c_iterator hint, NodeType& np)
{
if (!np) {
return this->end();
}
const_key_type& k = this->get_key(np.ptr_);
if (hint.p && this->key_eq()(k, this->get_key(hint.p))) {
return iterator(hint.p, hint.itb);
}
std::size_t const key_hash = this->hash(k);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer p = this->find_node_impl(k, itb);
if (p) {
return iterator(p, itb);
}
p = np.ptr_;
if (size_ + 1 > max_load_) {
this->reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
buckets_.insert_node(itb, p);
++size_;
np.ptr_ = node_pointer();
return iterator(p, itb);
}
template <typename Types2>
void merge_unique(boost::unordered::detail::table<Types2>& other)
{
typedef boost::unordered::detail::table<Types2> other_table;
BOOST_UNORDERED_STATIC_ASSERT(
(std::is_same<node_type, typename other_table::node_type>::value));
BOOST_ASSERT(this->node_alloc() == other.node_alloc());
if (other.size_ == 0) {
return;
}
this->reserve_for_insert(size_ + other.size_);
iterator last = other.end();
for (iterator pos = other.begin(); pos != last;) {
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));
if (this->find_node_impl(key, itb)) {
++pos;
continue;
}
iterator old = pos;
++pos;
node_pointer p = other.extract_by_iterator_unique(old);
buckets_.insert_node(itb, p);
++size_;
}
}
////////////////////////////////////////////////////////////////////////
// Insert range methods
//
// if hash function throws, or inserting > 1 element, basic exception
// safety strong otherwise
template <class InputIt>
void insert_range_unique(no_key, InputIt i, InputIt j)
{
hasher const& hf = this->hash_function();
node_allocator_type alloc = this->node_alloc();
for (; i != j; ++i) {
node_tmp tmp(detail::func::construct_node(alloc, *i), alloc);
value_type const& value = tmp.node_->value();
const_key_type& key = extractor::extract(value);
std::size_t const h = hf(key);
bucket_iterator itb = buckets_.at(buckets_.position(h));
node_pointer it = find_node_impl(key, itb);
if (it) {
continue;
}
if (size_ + 1 > max_load_) {
reserve(size_ + 1);
itb = buckets_.at(buckets_.position(h));
}
node_pointer nptr = tmp.release();
buckets_.insert_node(itb, nptr);
++size_;
}
}
////////////////////////////////////////////////////////////////////////
// Extract
inline node_pointer extract_by_iterator_unique(c_iterator i)
{
node_pointer p = i.p;
bucket_iterator itb = i.itb;
buckets_.extract_node(itb, p);
--size_;
return p;
}
////////////////////////////////////////////////////////////////////////
// Erase
//
template <class Key> std::size_t erase_key_unique_impl(Key const& k)
{
bucket_iterator itb = buckets_.at(buckets_.position(this->hash(k)));
node_pointer* pp = this->find_prev(k, itb);
if (!pp) {
return 0;
}
node_pointer p = *pp;
buckets_.extract_node_after(itb, pp);
this->delete_node(p);
--size_;
return 1;
}
iterator erase_node(c_iterator pos)
{
c_iterator next = pos;
++next;
bucket_iterator itb = pos.itb;
node_pointer* pp = std::addressof(itb->next);
while (*pp != pos.p) {
pp = std::addressof((*pp)->next);
}
buckets_.extract_node_after(itb, pp);
this->delete_node(pos.p);
--size_;
return iterator(next.p, next.itb);
}
iterator erase_nodes_range(c_iterator first, c_iterator last)
{
if (first == last) {
return iterator(last.p, last.itb);
}
// though `first` stores of a copy of a pointer to a node, we wish to
// mutate the pointers stored internally by the singly-linked list in
// each bucket group so we have to retrieve it manually by iterating
//
bucket_iterator itb = first.itb;
node_pointer* pp = std::addressof(itb->next);
while (*pp != first.p) {
pp = std::addressof((*pp)->next);
}
while (*pp != last.p) {
node_pointer p = *pp;
*pp = (*pp)->next;
this->delete_node(p);
--size_;
bool const at_end = !(*pp);
bool const is_empty_bucket = !itb->next;
if (at_end) {
if (is_empty_bucket) {
buckets_.unlink_bucket(itb++);
} else {
++itb;
}
pp = std::addressof(itb->next);
}
}
return iterator(last.p, last.itb);
}
////////////////////////////////////////////////////////////////////////
// fill_buckets_unique
void copy_buckets(table const& src, std::true_type)
{
BOOST_ASSERT(size_ == 0);
this->reserve_for_insert(src.size_);
for (iterator pos = src.begin(); pos != src.end(); ++pos) {
value_type const& value = *pos;
const_key_type& key = extractor::extract(value);
std::size_t const key_hash = this->hash(key);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_allocator_type alloc = this->node_alloc();
node_tmp tmp(detail::func::construct_node(alloc, value), alloc);
buckets_.insert_node(itb, tmp.release());
++size_;
}
}
void move_assign_buckets(table& src, std::true_type)
{
BOOST_ASSERT(size_ == 0);
BOOST_ASSERT(max_load_ >= src.size_);
iterator last = src.end();
node_allocator_type alloc = this->node_alloc();
for (iterator pos = src.begin(); pos != last; ++pos) {
value_type value = std::move(*pos);
const_key_type& key = extractor::extract(value);
std::size_t const key_hash = this->hash(key);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_tmp tmp(
detail::func::construct_node(alloc, std::move(value)), alloc);
buckets_.insert_node(itb, tmp.release());
++size_;
}
}
////////////////////////////////////////////////////////////////////////
// Equivalent keys
// Equality
bool equals_equiv(table const& other) const
{
if (this->size_ != other.size_)
return false;
iterator last = this->end();
for (iterator n1 = this->begin(); n1 != last;) {
const_key_type& k = extractor::extract(*n1);
iterator n2 = other.find(k);
if (n2 == other.end()) {
return false;
}
iterator end1 = this->next_group(k, n1);
iterator end2 = other.next_group(k, n2);
if (!group_equals_equiv(n1, end1, n2, end2)) {
return false;
}
n1 = end1;
}
return true;
}
static bool group_equals_equiv(
iterator n1, iterator end1, iterator n2, iterator end2)
{
for (;;) {
if (*n1 != *n2)
break;
++n1;
++n2;
if (n1 == end1)
return n2 == end2;
if (n2 == end2)
return false;
}
for (iterator n1a = n1, n2a = n2;;) {
++n1a;
++n2a;
if (n1a == end1) {
if (n2a == end2)
break;
else
return false;
}
if (n2a == end2)
return false;
}
iterator start = n1;
for (; n1 != end1; ++n1) {
value_type const& v = *n1;
if (!find_equiv(start, n1, v)) {
std::size_t matches = count_equal_equiv(n2, end2, v);
if (!matches)
return false;
iterator t = n1;
if (matches != 1 + count_equal_equiv(++t, end1, v))
return false;
}
}
return true;
}
static bool find_equiv(iterator n, iterator last, value_type const& v)
{
for (; n != last; ++n)
if (*n == v)
return true;
return false;
}
static std::size_t count_equal_equiv(
iterator n, iterator last, value_type const& v)
{
std::size_t count = 0;
for (; n != last; ++n)
if (*n == v)
++count;
return count;
}
// Emplace/Insert
iterator emplace_equiv(node_pointer n)
{
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));
node_pointer hint = this->find_node_impl(k, itb);
if (size_ + 1 > max_load_) {
this->reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
node_pointer p = a.release();
buckets_.insert_node_hint(itb, p, hint);
++size_;
return iterator(p, itb);
}
iterator emplace_hint_equiv(c_iterator hint, node_pointer n)
{
node_tmp a(n, this->node_alloc());
const_key_type& k = this->get_key(a.node_);
bucket_iterator itb = hint.itb;
node_pointer p = hint.p;
std::size_t key_hash = 0u;
bool const needs_rehash = (size_ + 1 > max_load_);
bool const usable_hint = (p && this->key_eq()(k, this->get_key(p)));
if (!usable_hint) {
key_hash = this->hash(k);
itb = buckets_.at(buckets_.position(key_hash));
p = this->find_node_impl(k, itb);
} else if (usable_hint && needs_rehash) {
key_hash = this->hash(k);
}
if (needs_rehash) {
this->reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
a.release();
buckets_.insert_node_hint(itb, n, p);
++size_;
return iterator(n, itb);
}
void emplace_no_rehash_equiv(node_pointer n)
{
BOOST_ASSERT(size_ + 1 <= max_load_);
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));
node_pointer hint = this->find_node_impl(k, itb);
node_pointer p = a.release();
buckets_.insert_node_hint(itb, p, hint);
++size_;
}
template <typename NodeType>
iterator move_insert_node_type_equiv(NodeType& np)
{
iterator result;
if (np) {
this->reserve_for_insert(size_ + 1);
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));
node_pointer hint = this->find_node_impl(k, itb);
buckets_.insert_node_hint(itb, np.ptr_, hint);
++size_;
result = iterator(np.ptr_, itb);
np.ptr_ = node_pointer();
}
return result;
}
template <typename NodeType>
iterator move_insert_node_type_with_hint_equiv(
c_iterator hint, NodeType& np)
{
iterator result;
if (np) {
bucket_iterator itb = hint.itb;
node_pointer pos = hint.p;
const_key_type& k = this->get_key(np.ptr_);
std::size_t key_hash = this->hash(k);
if (size_ + 1 > max_load_) {
this->reserve(size_ + 1);
itb = buckets_.at(buckets_.position(key_hash));
}
if (hint.p && this->key_eq()(k, this->get_key(hint.p))) {
} else {
itb = buckets_.at(buckets_.position(key_hash));
pos = this->find_node_impl(k, itb);
}
buckets_.insert_node_hint(itb, np.ptr_, pos);
++size_;
result = iterator(np.ptr_, itb);
np.ptr_ = node_pointer();
}
return result;
}
////////////////////////////////////////////////////////////////////////
// Insert range methods
// if hash function throws, or inserting > 1 element, basic exception
// safety. Strong otherwise
template <class I>
typename boost::unordered::detail::enable_if_forward<I, void>::type
insert_range_equiv(I i, I j)
{
if (i == j)
return;
std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
if (distance == 1) {
emplace_equiv(boost::unordered::detail::func::construct_node(
this->node_alloc(), *i));
} else {
// Only require basic exception safety here
this->reserve_for_insert(size_ + distance);
for (; i != j; ++i) {
emplace_no_rehash_equiv(
boost::unordered::detail::func::construct_node(
this->node_alloc(), *i));
}
}
}
template <class I>
typename boost::unordered::detail::disable_if_forward<I, void>::type
insert_range_equiv(I i, I j)
{
for (; i != j; ++i) {
emplace_equiv(boost::unordered::detail::func::construct_node(
this->node_alloc(), *i));
}
}
////////////////////////////////////////////////////////////////////////
// Extract
inline node_pointer extract_by_iterator_equiv(c_iterator n)
{
node_pointer p = n.p;
bucket_iterator itb = n.itb;
buckets_.extract_node(itb, p);
--size_;
return p;
}
////////////////////////////////////////////////////////////////////////
// Erase
//
// no throw
template <class Key> std::size_t erase_key_equiv_impl(Key const& k)
{
std::size_t deleted_count = 0;
bucket_iterator itb = buckets_.at(buckets_.position(this->hash(k)));
node_pointer* pp = this->find_prev(k, itb);
if (pp) {
while (*pp && this->key_eq()(this->get_key(*pp), k)) {
node_pointer p = *pp;
*pp = (*pp)->next;
this->delete_node(p);
--size_;
++deleted_count;
}
if (!itb->next) {
buckets_.unlink_bucket(itb);
}
}
return deleted_count;
}
std::size_t erase_key_equiv(const_key_type& k)
{
return this->erase_key_equiv_impl(k);
}
////////////////////////////////////////////////////////////////////////
// fill_buckets
void copy_buckets(table const& src, std::false_type)
{
BOOST_ASSERT(size_ == 0);
this->reserve_for_insert(src.size_);
iterator last = src.end();
for (iterator pos = src.begin(); pos != last; ++pos) {
value_type const& value = *pos;
const_key_type& key = extractor::extract(value);
std::size_t const key_hash = this->hash(key);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_allocator_type alloc = this->node_alloc();
node_tmp tmp(detail::func::construct_node(alloc, value), alloc);
node_pointer hint = this->find_node_impl(key, itb);
buckets_.insert_node_hint(itb, tmp.release(), hint);
++size_;
}
}
void move_assign_buckets(table& src, std::false_type)
{
BOOST_ASSERT(size_ == 0);
BOOST_ASSERT(max_load_ >= src.size_);
iterator last = src.end();
node_allocator_type alloc = this->node_alloc();
for (iterator pos = src.begin(); pos != last; ++pos) {
value_type value = std::move(*pos);
const_key_type& key = extractor::extract(value);
std::size_t const key_hash = this->hash(key);
bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
node_pointer hint = this->find_node_impl(key, itb);
node_tmp tmp(
detail::func::construct_node(alloc, std::move(value)), alloc);
buckets_.insert_node_hint(itb, tmp.release(), hint);
++size_;
}
}
};
//////////////////////////////////////////////////////////////////////////
// Clear
template <typename Types> inline void table<Types>::clear_impl()
{
bucket_iterator itb = buckets_.begin(), last = buckets_.end();
for (; itb != last;) {
bucket_iterator next_itb = itb;
++next_itb;
node_pointer* pp = std::addressof(itb->next);
while (*pp) {
node_pointer p = *pp;
buckets_.extract_node_after(itb, pp);
this->delete_node(p);
--size_;
}
itb = next_itb;
}
}
//////////////////////////////////////////////////////////////////////////
// Reserve & Rehash
// if hash function throws, basic exception safety
// strong otherwise.
template <typename Types>
inline void table<Types>::rehash(std::size_t num_buckets)
{
num_buckets = buckets_.bucket_count_for(
(std::max)(min_buckets(size_, mlf_), num_buckets));
if (num_buckets != this->bucket_count()) {
this->rehash_impl(num_buckets);
}
}
template <class Types>
inline void table<Types>::reserve(std::size_t num_elements)
{
std::size_t num_buckets = min_buckets(num_elements, mlf_);
this->rehash(num_buckets);
}
template <class Types>
inline void table<Types>::reserve_for_insert(std::size_t num_elements)
{
if (num_elements > max_load_) {
std::size_t const num_buckets = static_cast<std::size_t>(
1.0f + std::ceil(static_cast<float>(num_elements) / mlf_));
this->rehash_impl(num_buckets);
}
}
template <class Types>
inline void table<Types>::rehash_impl(std::size_t num_buckets)
{
bucket_array_type new_buckets(
num_buckets, buckets_.get_allocator());
BOOST_TRY
{
boost::unordered::detail::span<bucket_type> bspan = buckets_.raw();
bucket_type* pos = bspan.data;
std::size_t size = bspan.size;
bucket_type* last = pos + size;
for (; pos != last; ++pos) {
bucket_type& b = *pos;
for (node_pointer p = b.next; p;) {
node_pointer next_p = p->next;
transfer_node(p, b, new_buckets);
p = next_p;
b.next = p;
}
}
}
BOOST_CATCH(...)
{
for (bucket_iterator pos = new_buckets.begin();
pos != new_buckets.end(); ++pos) {
bucket_type& b = *pos;
for (node_pointer p = b.next; p;) {
node_pointer next_p = p->next;
delete_node(p);
--size_;
p = next_p;
}
}
buckets_.unlink_empty_buckets();
BOOST_RETHROW
}
BOOST_CATCH_END
buckets_ = std::move(new_buckets);
recalculate_max_load();
}
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
////////////////////////////////////////////////////////////////////////
// key extractors
//
// no throw
//
// 'extract_key' is called with the emplace parameters to return a
// key if available or 'no_key' is one isn't and will need to be
// constructed. This could be done by overloading the emplace
// implementation
// for the different cases, but that's a bit tricky on compilers without
// variadic templates.
template <typename Key, typename T> struct is_key
{
template <typename T2> static choice1::type test(T2 const&);
static choice2::type test(Key const&);
enum
{
value = sizeof(test(boost::unordered::detail::make<T>())) ==
sizeof(choice2::type)
};
typedef typename std::conditional<value, Key const&, no_key>::type type;
};
template <class ValueType> struct set_extractor
{
typedef ValueType value_type;
typedef ValueType key_type;
static key_type const& extract(value_type const& v) { return v; }
static key_type const& extract(value_type&& v) { return v; }
static no_key extract() { return no_key(); }
template <class Arg> static no_key extract(Arg const&)
{
return no_key();
}
template <class Arg1, class Arg2, class... Args>
static no_key extract(Arg1 const&, Arg2 const&, Args const&...)
{
return no_key();
}
};
template <class ValueType> struct map_extractor
{
typedef ValueType value_type;
typedef typename std::remove_const<typename boost::unordered::detail::
pair_traits<ValueType>::first_type>::type key_type;
static key_type const& extract(value_type const& v) { return v.first; }
template <class Second>
static key_type const& extract(std::pair<key_type, Second> const& v)
{
return v.first;
}
template <class Second>
static key_type const& extract(
std::pair<key_type const, Second> const& v)
{
return v.first;
}
template <class Arg1>
static key_type const& extract(key_type const& k, Arg1 const&)
{
return k;
}
static no_key extract() { return no_key(); }
template <class Arg> static no_key extract(Arg const&)
{
return no_key();
}
template <class Arg1, class Arg2>
static typename std::conditional<
(is_similar<Arg1, key_type>::value ||
is_complete_and_move_constructible<key_type>::value),
converting_key, no_key>::type
extract(Arg1 const&, Arg2 const&)
{
return {};
}
template <class Arg1, class Arg2, class Arg3, class... Args>
static no_key extract(
Arg1 const&, Arg2 const&, Arg3 const&, Args const&...)
{
return no_key();
}
template <template <class...> class Tuple, typename T2>
static no_key extract(
std::piecewise_construct_t, Tuple<> const&, T2 const&)
{
return no_key();
}
template <template <typename...> class Tuple, typename T, typename T2,
typename... Args>
static auto extract(
std::piecewise_construct_t, Tuple<T, Args...> const& k, T2 const&) ->
typename std::enable_if<
!std::is_same<T, boost::tuples::null_type>::value,
typename is_key<key_type, T>::type>::type
{
using std::get;
return typename is_key<key_type, T>::type(get<0>(k));
}
};
template <class Container, class Predicate>
typename Container::size_type erase_if(Container& c, Predicate& pred)
{
typedef typename Container::size_type size_type;
typedef typename Container::iterator iterator;
size_type const size = c.size();
for (iterator pos = c.begin(), last = c.end(); pos != last;) {
if (pred(*pos)) {
pos = c.erase(pos);
} else {
++pos;
}
}
return (size - c.size());
}
} // namespace detail
} // namespace unordered
} // namespace boost
#endif