2010-05-11 19:42:16 +00:00
|
|
|
// -*- C++ -*-
|
2021-11-17 16:25:01 -05:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-05-11 19:42:16 +00:00
|
|
|
//
|
2019-01-19 10:56:40 +00:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-05-11 19:42:16 +00:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#ifndef _LIBCPP_UNORDERED_SET
|
|
|
|
|
#define _LIBCPP_UNORDERED_SET
|
|
|
|
|
|
2023-12-04 15:17:31 -05:00
|
|
|
// clang-format off
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
unordered_set synopsis
|
|
|
|
|
|
|
|
|
|
#include <initializer_list>
|
|
|
|
|
|
|
|
|
|
namespace std
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
|
|
|
|
|
class Alloc = allocator<Value>>
|
|
|
|
|
class unordered_set
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
// types
|
|
|
|
|
typedef Value key_type;
|
|
|
|
|
typedef key_type value_type;
|
|
|
|
|
typedef Hash hasher;
|
|
|
|
|
typedef Pred key_equal;
|
|
|
|
|
typedef Alloc allocator_type;
|
|
|
|
|
typedef value_type& reference;
|
|
|
|
|
typedef const value_type& const_reference;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::pointer pointer;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::size_type size_type;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
typedef /unspecified/ iterator;
|
|
|
|
|
typedef /unspecified/ const_iterator;
|
|
|
|
|
typedef /unspecified/ local_iterator;
|
|
|
|
|
typedef /unspecified/ const_local_iterator;
|
|
|
|
|
|
2018-08-01 01:33:38 +00:00
|
|
|
typedef unspecified node_type unspecified; // C++17
|
|
|
|
|
typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type; // C++17
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_set()
|
|
|
|
|
noexcept(
|
|
|
|
|
is_nothrow_default_constructible<hasher>::value &&
|
|
|
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
|
|
|
|
explicit unordered_set(size_type n, const hasher& hf = hasher(),
|
2010-05-11 19:42:16 +00:00
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
unordered_set(InputIterator f, InputIterator l,
|
|
|
|
|
size_type n = 0, const hasher& hf = hasher(),
|
|
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_set(from_range_t, R&& rg, size_type n = see below,
|
|
|
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type()); // C++23
|
2010-05-11 19:42:16 +00:00
|
|
|
explicit unordered_set(const allocator_type&);
|
|
|
|
|
unordered_set(const unordered_set&);
|
|
|
|
|
unordered_set(const unordered_set&, const Allocator&);
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_set(unordered_set&&)
|
|
|
|
|
noexcept(
|
|
|
|
|
is_nothrow_move_constructible<hasher>::value &&
|
|
|
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
2010-05-11 19:42:16 +00:00
|
|
|
unordered_set(unordered_set&&, const Allocator&);
|
|
|
|
|
unordered_set(initializer_list<value_type>, size_type n = 0,
|
|
|
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
2013-09-30 21:33:51 +00:00
|
|
|
unordered_set(size_type n, const allocator_type& a); // C++14
|
|
|
|
|
unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
|
|
|
|
|
template <class InputIterator>
|
2019-05-29 16:01:36 +00:00
|
|
|
unordered_set(InputIterator f, InputIterator l, size_type n,
|
2013-09-30 21:33:51 +00:00
|
|
|
const hasher& hf, const allocator_type& a); // C++14
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
|
|
|
|
|
: unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
|
|
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
|
|
|
|
|
: unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } // C++23
|
2013-09-30 21:33:51 +00:00
|
|
|
unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
|
|
|
|
|
unordered_set(initializer_list<value_type> il, size_type n,
|
|
|
|
|
const hasher& hf, const allocator_type& a); // C++14
|
2010-05-11 19:42:16 +00:00
|
|
|
~unordered_set();
|
|
|
|
|
unordered_set& operator=(const unordered_set&);
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_set& operator=(unordered_set&&)
|
|
|
|
|
noexcept(
|
|
|
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
|
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
|
|
|
|
is_nothrow_move_assignable<hasher>::value &&
|
|
|
|
|
is_nothrow_move_assignable<key_equal>::value);
|
2010-05-11 19:42:16 +00:00
|
|
|
unordered_set& operator=(initializer_list<value_type>);
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
bool empty() const noexcept;
|
|
|
|
|
size_type size() const noexcept;
|
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
iterator begin() noexcept;
|
|
|
|
|
iterator end() noexcept;
|
|
|
|
|
const_iterator begin() const noexcept;
|
|
|
|
|
const_iterator end() const noexcept;
|
|
|
|
|
const_iterator cbegin() const noexcept;
|
|
|
|
|
const_iterator cend() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class... Args>
|
|
|
|
|
pair<iterator, bool> emplace(Args&&... args);
|
|
|
|
|
template <class... Args>
|
|
|
|
|
iterator emplace_hint(const_iterator position, Args&&... args);
|
|
|
|
|
pair<iterator, bool> insert(const value_type& obj);
|
|
|
|
|
pair<iterator, bool> insert(value_type&& obj);
|
|
|
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
|
|
|
|
iterator insert(const_iterator hint, value_type&& obj);
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
void insert_range(R&& rg); // C++23
|
2010-05-11 19:42:16 +00:00
|
|
|
void insert(initializer_list<value_type>);
|
|
|
|
|
|
2018-08-01 01:33:38 +00:00
|
|
|
node_type extract(const_iterator position); // C++17
|
|
|
|
|
node_type extract(const key_type& x); // C++17
|
|
|
|
|
insert_return_type insert(node_type&& nh); // C++17
|
|
|
|
|
iterator insert(const_iterator hint, node_type&& nh); // C++17
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 13:35:00 +00:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-04 20:18:37 +00:00
|
|
|
void clear() noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_set<Key, H2, P2, Allocator>& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_set<Key, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_multiset<Key, H2, P2, Allocator>& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_multiset<Key, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
void swap(unordered_set&)
|
2015-07-13 20:04:56 +00:00
|
|
|
noexcept(allocator_traits<Allocator>::is_always_equal::value &&
|
|
|
|
|
noexcept(swap(declval<hasher&>(), declval<hasher&>())) &&
|
|
|
|
|
noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
hasher hash_function() const;
|
|
|
|
|
key_equal key_eq() const;
|
|
|
|
|
|
|
|
|
|
iterator find(const key_type& k);
|
|
|
|
|
const_iterator find(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
iterator find(const K& x); // C++20
|
|
|
|
|
template<typename K>
|
|
|
|
|
const_iterator find(const K& x) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type count(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
size_type count(const K& k) const; // C++20
|
2019-07-16 03:21:01 +00:00
|
|
|
bool contains(const key_type& k) const; // C++20
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
bool contains(const K& k) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
pair<iterator, iterator> equal_range(const key_type& k);
|
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
pair<iterator, iterator> equal_range(const K& k); // C++20
|
|
|
|
|
template<typename K>
|
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
size_type bucket_count() const noexcept;
|
|
|
|
|
size_type max_bucket_count() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
size_type bucket_size(size_type n) const;
|
|
|
|
|
size_type bucket(const key_type& k) const;
|
|
|
|
|
|
|
|
|
|
local_iterator begin(size_type n);
|
|
|
|
|
local_iterator end(size_type n);
|
|
|
|
|
const_local_iterator begin(size_type n) const;
|
|
|
|
|
const_local_iterator end(size_type n) const;
|
|
|
|
|
const_local_iterator cbegin(size_type n) const;
|
|
|
|
|
const_local_iterator cend(size_type n) const;
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
float load_factor() const noexcept;
|
|
|
|
|
float max_load_factor() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
void max_load_factor(float z);
|
|
|
|
|
void rehash(size_type n);
|
|
|
|
|
void reserve(size_type n);
|
|
|
|
|
};
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class InputIterator,
|
|
|
|
|
class Hash = hash<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
class Pred = equal_to<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
|
|
|
|
|
unordered_set(InputIterator, InputIterator, typename see below::size_type = see below,
|
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_set<typename iterator_traits<InputIterator>::value_type,
|
|
|
|
|
Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template<ranges::input_range R,
|
|
|
|
|
class Hash = hash<ranges::range_value_t<R>>,
|
|
|
|
|
class Pred = equal_to<ranges::range_value_t<R>>,
|
|
|
|
|
class Allocator = allocator<ranges::range_value_t<R>>>
|
|
|
|
|
unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class T, class Hash = hash<T>,
|
|
|
|
|
class Pred = equal_to<T>, class Allocator = allocator<T>>
|
|
|
|
|
unordered_set(initializer_list<T>, typename see below::size_type = see below,
|
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_set<T, Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
|
unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_set<typename iterator_traits<InputIterator>::value_type,
|
|
|
|
|
hash<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
equal_to<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class InputIterator, class Hash, class Allocator>
|
|
|
|
|
unordered_set(InputIterator, InputIterator, typename see below::size_type,
|
|
|
|
|
Hash, Allocator)
|
|
|
|
|
-> unordered_set<typename iterator_traits<InputIterator>::value_type, Hash,
|
|
|
|
|
equal_to<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
Allocator>; // C++17
|
|
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template<ranges::input_range R, class Allocator>
|
|
|
|
|
unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
|
|
|
|
template<ranges::input_range R, class Allocator>
|
|
|
|
|
unordered_set(from_range_t, R&&, Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
|
|
|
|
template<ranges::input_range R, class Hash, class Allocator>
|
|
|
|
|
unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<R>, Hash,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class T, class Allocator>
|
|
|
|
|
unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_set<T, hash<T>, equal_to<T>, Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class T, class Hash, class Allocator>
|
|
|
|
|
unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
|
|
|
|
|
-> unordered_set<T, Hash, equal_to<T>, Allocator>; // C++17
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_set<Value, Hash, Pred, Alloc>& y)
|
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
bool
|
|
|
|
|
operator==(const unordered_set<Value, Hash, Pred, Alloc>& x,
|
|
|
|
|
const unordered_set<Value, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
bool
|
|
|
|
|
operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x,
|
2023-06-11 08:39:49 +03:00
|
|
|
const unordered_set<Value, Hash, Pred, Alloc>& y); // removed in C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
|
|
|
|
|
class Alloc = allocator<Value>>
|
|
|
|
|
class unordered_multiset
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
// types
|
|
|
|
|
typedef Value key_type;
|
|
|
|
|
typedef key_type value_type;
|
|
|
|
|
typedef Hash hasher;
|
|
|
|
|
typedef Pred key_equal;
|
|
|
|
|
typedef Alloc allocator_type;
|
|
|
|
|
typedef value_type& reference;
|
|
|
|
|
typedef const value_type& const_reference;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::pointer pointer;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::size_type size_type;
|
|
|
|
|
typedef typename allocator_traits<allocator_type>::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
typedef /unspecified/ iterator;
|
|
|
|
|
typedef /unspecified/ const_iterator;
|
|
|
|
|
typedef /unspecified/ local_iterator;
|
|
|
|
|
typedef /unspecified/ const_local_iterator;
|
|
|
|
|
|
2018-08-01 01:33:38 +00:00
|
|
|
typedef unspecified node_type unspecified; // C++17
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_multiset()
|
|
|
|
|
noexcept(
|
|
|
|
|
is_nothrow_default_constructible<hasher>::value &&
|
|
|
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
|
|
|
|
explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
|
2010-05-11 19:42:16 +00:00
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
unordered_multiset(InputIterator f, InputIterator l,
|
|
|
|
|
size_type n = 0, const hasher& hf = hasher(),
|
|
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_multiset(from_range_t, R&& rg, size_type n = see below,
|
|
|
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type()); // C++23
|
2010-05-11 19:42:16 +00:00
|
|
|
explicit unordered_multiset(const allocator_type&);
|
|
|
|
|
unordered_multiset(const unordered_multiset&);
|
|
|
|
|
unordered_multiset(const unordered_multiset&, const Allocator&);
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_multiset(unordered_multiset&&)
|
|
|
|
|
noexcept(
|
|
|
|
|
is_nothrow_move_constructible<hasher>::value &&
|
|
|
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
2010-05-11 19:42:16 +00:00
|
|
|
unordered_multiset(unordered_multiset&&, const Allocator&);
|
|
|
|
|
unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
|
|
|
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
|
|
|
|
const allocator_type& a = allocator_type());
|
2013-09-30 21:33:51 +00:00
|
|
|
unordered_multiset(size_type n, const allocator_type& a); // C++14
|
|
|
|
|
unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
unordered_multiset(InputIterator f, InputIterator l, size_type n,
|
|
|
|
|
const hasher& hf, const allocator_type& a); // C++14
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
|
|
|
|
|
: unordered_multiset(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
|
|
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
|
|
|
|
|
: unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } // C++23
|
2013-09-30 21:33:51 +00:00
|
|
|
unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
|
2019-05-29 16:01:36 +00:00
|
|
|
unordered_multiset(initializer_list<value_type> il, size_type n,
|
2013-09-30 21:33:51 +00:00
|
|
|
const hasher& hf, const allocator_type& a); // C++14
|
2010-05-11 19:42:16 +00:00
|
|
|
~unordered_multiset();
|
|
|
|
|
unordered_multiset& operator=(const unordered_multiset&);
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_multiset& operator=(unordered_multiset&&)
|
|
|
|
|
noexcept(
|
|
|
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
|
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
|
|
|
|
is_nothrow_move_assignable<hasher>::value &&
|
|
|
|
|
is_nothrow_move_assignable<key_equal>::value);
|
2010-05-11 19:42:16 +00:00
|
|
|
unordered_multiset& operator=(initializer_list<value_type>);
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
bool empty() const noexcept;
|
|
|
|
|
size_type size() const noexcept;
|
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
iterator begin() noexcept;
|
|
|
|
|
iterator end() noexcept;
|
|
|
|
|
const_iterator begin() const noexcept;
|
|
|
|
|
const_iterator end() const noexcept;
|
|
|
|
|
const_iterator cbegin() const noexcept;
|
|
|
|
|
const_iterator cend() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class... Args>
|
|
|
|
|
iterator emplace(Args&&... args);
|
|
|
|
|
template <class... Args>
|
|
|
|
|
iterator emplace_hint(const_iterator position, Args&&... args);
|
|
|
|
|
iterator insert(const value_type& obj);
|
|
|
|
|
iterator insert(value_type&& obj);
|
|
|
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
|
|
|
|
iterator insert(const_iterator hint, value_type&& obj);
|
|
|
|
|
template <class InputIterator>
|
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
2023-07-10 17:16:56 -07:00
|
|
|
template<container-compatible-range<value_type> R>
|
|
|
|
|
void insert_range(R&& rg); // C++23
|
2010-05-11 19:42:16 +00:00
|
|
|
void insert(initializer_list<value_type>);
|
|
|
|
|
|
2018-08-01 01:33:38 +00:00
|
|
|
node_type extract(const_iterator position); // C++17
|
|
|
|
|
node_type extract(const key_type& x); // C++17
|
|
|
|
|
iterator insert(node_type&& nh); // C++17
|
|
|
|
|
iterator insert(const_iterator hint, node_type&& nh); // C++17
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 13:35:00 +00:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-04 20:18:37 +00:00
|
|
|
void clear() noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_multiset<Key, H2, P2, Allocator>& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_multiset<Key, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_set<Key, H2, P2, Allocator>& source); // C++17
|
|
|
|
|
template<class H2, class P2>
|
|
|
|
|
void merge(unordered_set<Key, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
void swap(unordered_multiset&)
|
2015-07-13 20:04:56 +00:00
|
|
|
noexcept(allocator_traits<Allocator>::is_always_equal::value &&
|
|
|
|
|
noexcept(swap(declval<hasher&>(), declval<hasher&>())) &&
|
|
|
|
|
noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
hasher hash_function() const;
|
|
|
|
|
key_equal key_eq() const;
|
|
|
|
|
|
|
|
|
|
iterator find(const key_type& k);
|
|
|
|
|
const_iterator find(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
iterator find(const K& x); // C++20
|
|
|
|
|
template<typename K>
|
|
|
|
|
const_iterator find(const K& x) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type count(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
size_type count(const K& k) const; // C++20
|
2019-07-16 03:21:01 +00:00
|
|
|
bool contains(const key_type& k) const; // C++20
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
bool contains(const K& k) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
pair<iterator, iterator> equal_range(const key_type& k);
|
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
|
2020-11-10 07:49:55 -05:00
|
|
|
template<typename K>
|
|
|
|
|
pair<iterator, iterator> equal_range(const K& k); // C++20
|
|
|
|
|
template<typename K>
|
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
size_type bucket_count() const noexcept;
|
|
|
|
|
size_type max_bucket_count() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
size_type bucket_size(size_type n) const;
|
|
|
|
|
size_type bucket(const key_type& k) const;
|
|
|
|
|
|
|
|
|
|
local_iterator begin(size_type n);
|
|
|
|
|
local_iterator end(size_type n);
|
|
|
|
|
const_local_iterator begin(size_type n) const;
|
|
|
|
|
const_local_iterator end(size_type n) const;
|
|
|
|
|
const_local_iterator cbegin(size_type n) const;
|
|
|
|
|
const_local_iterator cend(size_type n) const;
|
|
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
float load_factor() const noexcept;
|
|
|
|
|
float max_load_factor() const noexcept;
|
2010-05-11 19:42:16 +00:00
|
|
|
void max_load_factor(float z);
|
|
|
|
|
void rehash(size_type n);
|
|
|
|
|
void reserve(size_type n);
|
|
|
|
|
};
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class InputIterator,
|
|
|
|
|
class Hash = hash<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
class Pred = equal_to<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
|
|
|
|
|
unordered_multiset(InputIterator, InputIterator, see below::size_type = see below,
|
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_multiset<typename iterator_traits<InputIterator>::value_type,
|
|
|
|
|
Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template<ranges::input_range R,
|
|
|
|
|
class Hash = hash<ranges::range_value_t<R>>,
|
|
|
|
|
class Pred = equal_to<ranges::range_value_t<R>>,
|
|
|
|
|
class Allocator = allocator<ranges::range_value_t<R>>>
|
|
|
|
|
unordered_multiset(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class T, class Hash = hash<T>,
|
|
|
|
|
class Pred = equal_to<T>, class Allocator = allocator<T>>
|
|
|
|
|
unordered_multiset(initializer_list<T>, typename see below::size_type = see below,
|
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
|
-> unordered_multiset<T, Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
|
unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_multiset<typename iterator_traits<InputIterator>::value_type,
|
|
|
|
|
hash<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
equal_to<typename iterator_traits<InputIterator>::value_type>,
|
|
|
|
|
Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class InputIterator, class Hash, class Allocator>
|
|
|
|
|
unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
|
|
|
|
|
Hash, Allocator)
|
|
|
|
|
-> unordered_multiset<typename iterator_traits<InputIterator>::value_type, Hash,
|
|
|
|
|
equal_to<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
|
|
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template<ranges::input_range R, class Allocator>
|
|
|
|
|
unordered_multiset(from_range_t, R&&, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
|
|
|
|
template<ranges::input_range R, class Allocator>
|
|
|
|
|
unordered_multiset(from_range_t, R&&, Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
|
|
|
|
template<ranges::input_range R, class Hash, class Allocator>
|
|
|
|
|
unordered_multiset(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<R>, Hash,
|
|
|
|
|
equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
|
|
|
|
|
|
2021-11-09 09:21:02 -08:00
|
|
|
template<class T, class Allocator>
|
|
|
|
|
unordered_multiset(initializer_list<T>, typename see below::size_type, Allocator)
|
|
|
|
|
-> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>; // C++17
|
|
|
|
|
|
|
|
|
|
template<class T, class Hash, class Allocator>
|
|
|
|
|
unordered_multiset(initializer_list<T>, typename see below::size_type, Hash, Allocator)
|
|
|
|
|
-> unordered_multiset<T, Hash, equal_to<T>, Allocator>; // C++17
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
|
2011-06-04 20:18:37 +00:00
|
|
|
unordered_multiset<Value, Hash, Pred, Alloc>& y)
|
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2018-12-14 18:49:35 +00:00
|
|
|
template <class K, class T, class H, class P, class A, class Predicate>
|
2020-05-02 13:58:03 +02:00
|
|
|
typename unordered_set<K, T, H, P, A>::size_type
|
|
|
|
|
erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred); // C++20
|
2018-12-14 18:49:35 +00:00
|
|
|
|
|
|
|
|
template <class K, class T, class H, class P, class A, class Predicate>
|
2020-05-02 13:58:03 +02:00
|
|
|
typename unordered_multiset<K, T, H, P, A>::size_type
|
|
|
|
|
erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred); // C++20
|
2018-12-14 18:49:35 +00:00
|
|
|
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
bool
|
|
|
|
|
operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
|
|
|
|
|
const unordered_multiset<Value, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
|
|
template <class Value, class Hash, class Pred, class Alloc>
|
|
|
|
|
bool
|
|
|
|
|
operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
|
2023-06-11 08:39:49 +03:00
|
|
|
const unordered_multiset<Value, Hash, Pred, Alloc>& y); // removed in C++20
|
2010-05-11 19:42:16 +00:00
|
|
|
} // std
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2023-12-04 15:17:31 -05:00
|
|
|
// clang-format on
|
|
|
|
|
|
2024-12-21 13:01:48 +01:00
|
|
|
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
|
|
|
# include <__cxx03/unordered_set>
|
|
|
|
|
#else
|
2024-12-10 16:02:12 +01:00
|
|
|
# include <__algorithm/is_permutation.h>
|
|
|
|
|
# include <__assert>
|
|
|
|
|
# include <__config>
|
|
|
|
|
# include <__functional/hash.h>
|
|
|
|
|
# include <__functional/is_transparent.h>
|
|
|
|
|
# include <__functional/operations.h>
|
|
|
|
|
# include <__hash_table>
|
|
|
|
|
# include <__iterator/distance.h>
|
|
|
|
|
# include <__iterator/erase_if_container.h>
|
|
|
|
|
# include <__iterator/iterator_traits.h>
|
|
|
|
|
# include <__iterator/ranges_iterator_traits.h>
|
|
|
|
|
# include <__memory/addressof.h>
|
|
|
|
|
# include <__memory/allocator.h>
|
|
|
|
|
# include <__memory/allocator_traits.h>
|
|
|
|
|
# include <__memory_resource/polymorphic_allocator.h>
|
|
|
|
|
# include <__node_handle>
|
|
|
|
|
# include <__ranges/concepts.h>
|
|
|
|
|
# include <__ranges/container_compatible_range.h>
|
|
|
|
|
# include <__ranges/from_range.h>
|
|
|
|
|
# include <__type_traits/container_traits.h>
|
|
|
|
|
# include <__type_traits/enable_if.h>
|
|
|
|
|
# include <__type_traits/invoke.h>
|
|
|
|
|
# include <__type_traits/is_allocator.h>
|
|
|
|
|
# include <__type_traits/is_integral.h>
|
|
|
|
|
# include <__type_traits/is_nothrow_assignable.h>
|
|
|
|
|
# include <__type_traits/is_nothrow_constructible.h>
|
|
|
|
|
# include <__type_traits/is_same.h>
|
|
|
|
|
# include <__type_traits/is_swappable.h>
|
|
|
|
|
# include <__type_traits/type_identity.h>
|
|
|
|
|
# include <__utility/forward.h>
|
|
|
|
|
# include <__utility/move.h>
|
|
|
|
|
# include <__utility/pair.h>
|
|
|
|
|
# include <version>
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2022-06-16 22:43:46 +02:00
|
|
|
// standard-mandated includes
|
|
|
|
|
|
|
|
|
|
// [iterator.range]
|
2024-12-10 16:02:12 +01:00
|
|
|
# include <__iterator/access.h>
|
|
|
|
|
# include <__iterator/data.h>
|
|
|
|
|
# include <__iterator/empty.h>
|
|
|
|
|
# include <__iterator/reverse_access.h>
|
|
|
|
|
# include <__iterator/size.h>
|
2022-06-16 22:43:46 +02:00
|
|
|
|
|
|
|
|
// [unord.set.syn]
|
2024-12-10 16:02:12 +01:00
|
|
|
# include <compare>
|
|
|
|
|
# include <initializer_list>
|
2022-06-16 22:43:46 +02:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
|
|
|
# pragma GCC system_header
|
|
|
|
|
# endif
|
2010-05-11 19:42:16 +00:00
|
|
|
|
[libc++] Fix missing and incorrect push/pop macros (#79204)
We recently noticed that the unwrap_iter.h file was pushing macros, but
it was pushing them again instead of popping them at the end of the
file. This led to libc++ basically swallowing any custom definition of
these macros in user code:
#define min HELLO
#include <algorithm>
// min is not HELLO anymore, it's not defined
While investigating this issue, I noticed that our push/pop pragmas were
actually entirely wrong too. Indeed, instead of pushing macros like
`move`, we'd push `move(int, int)` in the pragma, which is not a valid
macro name. As a result, we would not actually push macros like `move`
-- instead we'd simply undefine them. This led to the following code not
working:
#define move HELLO
#include <algorithm>
// move is not HELLO anymore
Fixing the pragma push/pop incantations led to a cascade of issues
because we use identifiers like `move` in a large number of places, and
all of these headers would now need to do the push/pop dance.
This patch fixes all these issues. First, it adds a check that we don't
swallow important names like min, max, move or refresh as explained
above. This is done by augmenting the existing
system_reserved_names.gen.py test to also check that the macros are what
we expect after including each header.
Second, it fixes the push/pop pragmas to work properly and adds missing
pragmas to all the files I could detect a failure in via the newly added
test.
rdar://121365472
2024-01-25 15:48:46 -05:00
|
|
|
_LIBCPP_PUSH_MACROS
|
2024-12-10 16:02:12 +01:00
|
|
|
# include <__undef_macros>
|
[libc++] Fix missing and incorrect push/pop macros (#79204)
We recently noticed that the unwrap_iter.h file was pushing macros, but
it was pushing them again instead of popping them at the end of the
file. This led to libc++ basically swallowing any custom definition of
these macros in user code:
#define min HELLO
#include <algorithm>
// min is not HELLO anymore, it's not defined
While investigating this issue, I noticed that our push/pop pragmas were
actually entirely wrong too. Indeed, instead of pushing macros like
`move`, we'd push `move(int, int)` in the pragma, which is not a valid
macro name. As a result, we would not actually push macros like `move`
-- instead we'd simply undefine them. This led to the following code not
working:
#define move HELLO
#include <algorithm>
// move is not HELLO anymore
Fixing the pragma push/pop incantations led to a cascade of issues
because we use identifiers like `move` in a large number of places, and
all of these headers would now need to do the push/pop dance.
This patch fixes all these issues. First, it adds a check that we don't
swallow important names like min, max, move or refresh as explained
above. This is done by augmenting the existing
system_reserved_names.gen.py test to also check that the macros are what
we expect after including each header.
Second, it fixes the push/pop pragmas to work properly and adds missing
pragmas to all the files I could detect a failure in via the newly added
test.
rdar://121365472
2024-01-25 15:48:46 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
class unordered_multiset;
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >
|
2025-04-09 23:47:57 +02:00
|
|
|
class unordered_set {
|
2010-05-11 19:42:16 +00:00
|
|
|
public:
|
|
|
|
|
// types
|
|
|
|
|
typedef _Value key_type;
|
|
|
|
|
typedef key_type value_type;
|
2022-03-18 17:49:02 +01:00
|
|
|
typedef __type_identity_t<_Hash> hasher;
|
|
|
|
|
typedef __type_identity_t<_Pred> key_equal;
|
|
|
|
|
typedef __type_identity_t<_Alloc> allocator_type;
|
2010-05-11 19:42:16 +00:00
|
|
|
typedef value_type& reference;
|
|
|
|
|
typedef const value_type& const_reference;
|
2024-06-25 16:13:48 +01:00
|
|
|
static_assert(__check_valid_allocator<allocator_type>::value, "");
|
2024-06-18 10:45:30 +02:00
|
|
|
static_assert(is_same<value_type, typename allocator_type::value_type>::value,
|
2023-01-20 14:49:55 -05:00
|
|
|
"Allocator::value_type must be same type as value_type");
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2022-10-08 22:17:32 +02:00
|
|
|
private:
|
2010-05-11 19:42:16 +00:00
|
|
|
typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
|
|
|
|
|
|
|
|
|
|
__table __table_;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
typedef typename __table::pointer pointer;
|
|
|
|
|
typedef typename __table::const_pointer const_pointer;
|
|
|
|
|
typedef typename __table::size_type size_type;
|
|
|
|
|
typedef typename __table::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
typedef typename __table::const_iterator iterator;
|
|
|
|
|
typedef typename __table::const_iterator const_iterator;
|
|
|
|
|
typedef typename __table::const_local_iterator local_iterator;
|
|
|
|
|
typedef typename __table::const_local_iterator const_local_iterator;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2018-08-01 01:33:38 +00:00
|
|
|
typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
|
|
|
|
|
typedef __insert_return_type<iterator, node_type> insert_return_type;
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-08-01 01:33:38 +00:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
|
2025-04-09 23:47:57 +02:00
|
|
|
friend class unordered_set;
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
|
2025-04-09 23:47:57 +02:00
|
|
|
friend class unordered_multiset;
|
2018-10-31 17:31:35 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
|
2023-01-23 10:27:14 +01:00
|
|
|
explicit _LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_set(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const allocator_type& __a)
|
|
|
|
|
: unordered_set(__n, hasher(), key_equal(), __a) {}
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_set(__n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last);
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_set(_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(
|
|
|
|
|
_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a);
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(
|
|
|
|
|
from_range_t,
|
|
|
|
|
_Range&& __range,
|
|
|
|
|
size_type __n = /*implementation-defined*/ 0,
|
|
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal(),
|
|
|
|
|
const allocator_type& __a = allocator_type())
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
|
|
|
|
if (__n > 0) {
|
|
|
|
|
__table_.__rehash_unique(__n);
|
|
|
|
|
}
|
|
|
|
|
insert_range(std::forward<_Range>(__range));
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
template <class _InputIterator>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
2019-05-29 16:01:36 +00:00
|
|
|
unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
|
2013-09-30 21:33:51 +00:00
|
|
|
: unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
|
|
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(
|
2013-09-30 21:33:51 +00:00
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
|
|
|
|
|
: unordered_set(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_set(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_set(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit unordered_set(const allocator_type& __a);
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u, const allocator_type& __a);
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u, const allocator_type& __a);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
2013-09-30 21:33:51 +00:00
|
|
|
unordered_set(initializer_list<value_type> __il,
|
|
|
|
|
size_type __n,
|
2010-05-11 19:42:16 +00:00
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal());
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set(
|
2010-05-11 19:42:16 +00:00
|
|
|
initializer_list<value_type> __il,
|
2013-09-30 21:33:51 +00:00
|
|
|
size_type __n,
|
2010-05-11 19:42:16 +00:00
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a);
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
2023-01-23 10:27:14 +01:00
|
|
|
unordered_set(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
|
2010-05-11 19:42:16 +00:00
|
|
|
: unordered_set(__il, __n, hasher(), key_equal(), __a) {}
|
2023-01-23 10:27:14 +01:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_set(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
|
2013-09-30 21:33:51 +00:00
|
|
|
: unordered_set(__il, __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
|
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-11 16:14:56 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI ~unordered_set() {
|
[libc++] Add custom clang-tidy checks
Reviewed By: #libc, ldionne
Spies: jwakely, beanz, smeenai, cfe-commits, tschuett, avogelsgesang, Mordante, sstefan1, libcxx-commits, ldionne, mgorny, arichardson, miyuki
Differential Revision: https://reviews.llvm.org/D131963
2022-08-13 22:33:12 +02:00
|
|
|
static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-11 16:14:56 +00:00
|
|
|
}
|
|
|
|
|
|
2011-07-01 19:24:36 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set& operator=(const unordered_set& __u) {
|
|
|
|
|
__table_ = __u.__table_;
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set& operator=(unordered_set&& __u)
|
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_set& operator=(initializer_list<value_type> __il);
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
|
2010-05-11 19:42:16 +00:00
|
|
|
return allocator_type(__table_.__node_alloc());
|
2011-06-04 20:18:37 +00:00
|
|
|
}
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2024-09-12 21:18:43 +02:00
|
|
|
[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
|
2022-03-24 09:03:56 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
|
2017-04-18 22:37:32 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
|
2010-09-23 18:58:28 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
|
2011-06-30 21:18:19 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
|
2010-09-23 18:58:28 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
|
2023-06-29 14:49:45 -07:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
|
2022-03-24 09:03:56 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class... _Args>
|
2017-04-18 22:37:32 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
|
2011-06-30 21:18:19 +00:00
|
|
|
return __table_.__emplace_unique(std::forward<_Args>(__args)...);
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class... _Args>
|
2023-06-29 14:49:45 -07:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator, _Args&&... __args) {
|
2011-06-30 21:18:19 +00:00
|
|
|
return __table_.__emplace_unique(std::forward<_Args>(__args)...).first;
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __x) {
|
2023-10-12 20:13:08 -07:00
|
|
|
return __table_.__insert_unique(std::move(__x));
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2011-06-30 21:18:19 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, value_type&& __x) { return insert(std::move(__x)).first; }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2017-04-18 22:37:32 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2017-04-18 22:37:32 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return __table_.__insert_unique(__x); }
|
|
|
|
|
|
2023-06-29 14:49:45 -07:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; }
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _InputIterator>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
|
|
|
|
|
for (auto&& __element : __range) {
|
|
|
|
|
__table_.__insert_unique(std::forward<decltype(__element)>(__element));
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_unique(__k); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
|
|
|
|
|
return __table_.erase(__first, __last);
|
|
|
|
|
}
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2018-08-01 01:33:38 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI insert_return_type insert(node_type&& __nh) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
2018-08-01 01:33:38 +00:00
|
|
|
"node_type with incompatible allocator passed to unordered_set::insert()");
|
|
|
|
|
return __table_.template __node_handle_insert_unique< node_type, insert_return_type>(std::move(__nh));
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __h, node_type&& __nh) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
2018-08-01 01:33:38 +00:00
|
|
|
"node_type with incompatible allocator passed to unordered_set::insert()");
|
|
|
|
|
return __table_.template __node_handle_insert_unique<node_type>(__h, std::move(__nh));
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
|
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__key);
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
|
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__it);
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
__table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
__table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
__table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
__table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-08-01 01:33:38 +00:00
|
|
|
|
2024-06-18 11:01:43 +02:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void swap(unordered_set& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
|
2011-06-04 20:18:37 +00:00
|
|
|
__table_.swap(__u.__table_);
|
|
|
|
|
}
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
|
|
|
|
|
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
|
|
|
|
|
return __table_.find(__k);
|
|
|
|
|
}
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
|
|
|
|
|
return __table_.find(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
|
|
|
|
|
return __table_.__count_unique(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
|
|
|
|
|
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
|
|
|
|
|
return find(__k) != end();
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2020-11-10 07:49:55 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
|
|
|
|
|
return __table_.__equal_range_unique(__k);
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
|
|
|
|
|
return __table_.__equal_range_unique(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
|
|
|
|
|
return __table_.__equal_range_unique(__k);
|
|
|
|
|
}
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
|
|
|
|
|
return __table_.__equal_range_unique(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
|
2022-07-10 11:41:02 +02:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_unique(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_unique(__n); }
|
2010-05-11 19:42:16 +00:00
|
|
|
};
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Hash = hash<__iter_value_type<_InputIterator>>,
|
|
|
|
|
class _Pred = equal_to<__iter_value_type<_InputIterator>>,
|
|
|
|
|
class _Allocator = allocator<__iter_value_type<_InputIterator>>,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(_InputIterator,
|
|
|
|
|
_InputIterator,
|
|
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
|
|
|
|
_Allocator = _Allocator()) -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <ranges::input_range _Range,
|
|
|
|
|
class _Hash = hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
class _Pred = equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
class _Allocator = allocator<ranges::range_value_t<_Range>>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_set(
|
|
|
|
|
from_range_t,
|
|
|
|
|
_Range&&,
|
|
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
|
|
|
|
_Allocator = _Allocator()) -> unordered_set<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _Tp,
|
|
|
|
|
class _Hash = hash<_Tp>,
|
|
|
|
|
class _Pred = equal_to<_Tp>,
|
|
|
|
|
class _Allocator = allocator<_Tp>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(initializer_list<_Tp>,
|
2023-07-10 17:16:56 -07:00
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
2019-07-11 15:16:39 +00:00
|
|
|
_Allocator = _Allocator()) -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Allocator,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_set<__iter_value_type<_InputIterator>,
|
|
|
|
|
hash<__iter_value_type<_InputIterator>>,
|
|
|
|
|
equal_to<__iter_value_type<_InputIterator>>,
|
2023-07-10 17:16:56 -07:00
|
|
|
_Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_set<__iter_value_type<_InputIterator>, _Hash, equal_to<__iter_value_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
|
|
|
|
|
template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<_Range>,
|
|
|
|
|
hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
_Allocator>;
|
|
|
|
|
|
|
|
|
|
template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_set(from_range_t, _Range&&, _Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<_Range>,
|
|
|
|
|
hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
_Allocator>;
|
|
|
|
|
|
|
|
|
|
template <ranges::input_range _Range,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_set<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
|
|
|
|
|
|
|
|
|
|
template <class _Tp,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2019-07-11 15:16:39 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
|
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(_InputIterator __first, _InputIterator __last) {
|
|
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
|
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
|
|
|
|
|
_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
|
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const allocator_type& __a) : __table_(__a) {}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u) : __table_(__u.__table_) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__u.bucket_count());
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u, const allocator_type& __a)
|
|
|
|
|
: __table_(__u.__table_, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__u.bucket_count());
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
|
2011-06-30 21:18:19 +00:00
|
|
|
: __table_(std::move(__u.__table_)) {}
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u, const allocator_type& __a)
|
2011-06-30 21:18:19 +00:00
|
|
|
: __table_(std::move(__u.__table_), __a) {
|
2010-05-11 19:42:16 +00:00
|
|
|
if (__a != __u.get_allocator()) {
|
|
|
|
|
iterator __i = __u.begin();
|
|
|
|
|
while (__u.size() != 0)
|
2023-10-12 20:13:08 -07:00
|
|
|
__table_.__insert_unique(std::move(__u.__table_.remove(__i++)->__get_value()));
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(initializer_list<value_type> __il) {
|
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
|
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
|
|
|
|
|
initializer_list<value_type> __il,
|
|
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_unique(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
|
2011-06-30 21:18:19 +00:00
|
|
|
__table_ = std::move(__u.__table_);
|
2010-05-11 19:42:16 +00:00
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
|
|
|
|
|
unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
|
|
|
|
|
__table_.__assign_unique(__il.begin(), __il.end());
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2011-08-12 21:56:02 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
inline void unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
|
|
|
|
|
for (; __first != __last; ++__first)
|
|
|
|
|
__table_.__insert_unique(*__first);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
2010-09-23 18:58:28 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI void
|
2010-05-11 19:42:16 +00:00
|
|
|
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
|
2010-05-11 19:42:16 +00:00
|
|
|
__x.swap(__y);
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2020-05-02 13:58:03 +02:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
|
|
|
|
|
erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
|
2021-03-21 16:53:09 -04:00
|
|
|
return std::__libcpp_erase_if_container(__c, __pred);
|
2020-05-02 13:58:03 +02:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-12-14 18:49:35 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
|
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) {
|
|
|
|
|
if (__x.size() != __y.size())
|
|
|
|
|
return false;
|
|
|
|
|
typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
|
|
|
|
|
for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) {
|
|
|
|
|
const_iterator __j = __y.find(*__i);
|
|
|
|
|
if (__j == __ey || !(*__i == *__j))
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER <= 17
|
2023-06-11 08:39:49 +03:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
|
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) {
|
|
|
|
|
return !(__x == __y);
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-06-11 08:39:49 +03:00
|
|
|
|
2024-10-12 18:29:59 +01:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
struct __container_traits<unordered_set<_Value, _Hash, _Pred, _Alloc> > {
|
|
|
|
|
// http://eel.is/c++draft/unord.req.except#2
|
|
|
|
|
// For unordered associative containers, if an exception is thrown by any operation
|
|
|
|
|
// other than the container's hash function from within an insert or emplace function
|
|
|
|
|
// inserting a single element, the insertion has no effect.
|
|
|
|
|
static _LIBCPP_CONSTEXPR const bool __emplacement_has_strong_exception_safety_guarantee =
|
2025-01-20 18:00:15 +01:00
|
|
|
__is_nothrow_invocable_v<_Hash, const _Value&>;
|
2024-10-12 18:29:59 +01:00
|
|
|
};
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >
|
2025-04-09 23:47:57 +02:00
|
|
|
class unordered_multiset {
|
2010-05-11 19:42:16 +00:00
|
|
|
public:
|
|
|
|
|
// types
|
|
|
|
|
typedef _Value key_type;
|
|
|
|
|
typedef key_type value_type;
|
2022-03-18 17:49:02 +01:00
|
|
|
typedef __type_identity_t<_Hash> hasher;
|
|
|
|
|
typedef __type_identity_t<_Pred> key_equal;
|
|
|
|
|
typedef __type_identity_t<_Alloc> allocator_type;
|
2010-05-11 19:42:16 +00:00
|
|
|
typedef value_type& reference;
|
|
|
|
|
typedef const value_type& const_reference;
|
2024-06-18 10:45:30 +02:00
|
|
|
static_assert(is_same<value_type, typename allocator_type::value_type>::value,
|
2023-01-20 14:49:55 -05:00
|
|
|
"Allocator::value_type must be same type as value_type");
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
|
|
|
|
|
|
|
|
|
|
__table __table_;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
typedef typename __table::pointer pointer;
|
|
|
|
|
typedef typename __table::const_pointer const_pointer;
|
|
|
|
|
typedef typename __table::size_type size_type;
|
|
|
|
|
typedef typename __table::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
typedef typename __table::const_iterator iterator;
|
|
|
|
|
typedef typename __table::const_iterator const_iterator;
|
|
|
|
|
typedef typename __table::const_local_iterator local_iterator;
|
|
|
|
|
typedef typename __table::const_local_iterator const_local_iterator;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2018-08-01 01:33:38 +00:00
|
|
|
typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-08-01 01:33:38 +00:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
|
2025-04-09 23:47:57 +02:00
|
|
|
friend class unordered_set;
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
|
2025-04-09 23:47:57 +02:00
|
|
|
friend class unordered_multiset;
|
2018-10-31 17:31:35 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
|
2023-01-23 10:27:14 +01:00
|
|
|
explicit _LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(__n, hasher(), key_equal(), __a) {}
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(__n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last);
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
|
template <class _InputIterator>
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
2010-05-11 19:42:16 +00:00
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a);
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
from_range_t,
|
|
|
|
|
_Range&& __range,
|
|
|
|
|
size_type __n = /*implementation-defined*/ 0,
|
|
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal(),
|
|
|
|
|
const allocator_type& __a = allocator_type())
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
|
|
|
|
if (__n > 0) {
|
|
|
|
|
__table_.__rehash_multi(__n);
|
|
|
|
|
}
|
|
|
|
|
insert_range(std::forward<_Range>(__range));
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
template <class _InputIterator>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
2019-05-29 16:01:36 +00:00
|
|
|
unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
|
2013-09-30 21:33:51 +00:00
|
|
|
: unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_multiset(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit unordered_multiset(const allocator_type& __a);
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u)
|
|
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il);
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
initializer_list<value_type> __il,
|
|
|
|
|
size_type __n,
|
2010-05-11 19:42:16 +00:00
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
|
const key_equal& __eql = key_equal());
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset(
|
|
|
|
|
initializer_list<value_type> __il,
|
|
|
|
|
size_type __n,
|
2010-05-11 19:42:16 +00:00
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a);
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 14
|
2013-09-30 21:33:51 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI
|
|
|
|
|
unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
|
: unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
|
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-11 16:14:56 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI ~unordered_multiset() {
|
[libc++] Add custom clang-tidy checks
Reviewed By: #libc, ldionne
Spies: jwakely, beanz, smeenai, cfe-commits, tschuett, avogelsgesang, Mordante, sstefan1, libcxx-commits, ldionne, mgorny, arichardson, miyuki
Differential Revision: https://reviews.llvm.org/D131963
2022-08-13 22:33:12 +02:00
|
|
|
static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-11 16:14:56 +00:00
|
|
|
}
|
|
|
|
|
|
2011-07-01 19:24:36 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(const unordered_multiset& __u) {
|
|
|
|
|
__table_ = __u.__table_;
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(unordered_multiset&& __u)
|
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
2023-01-23 10:27:14 +01:00
|
|
|
_LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(initializer_list<value_type> __il);
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
|
2010-05-11 19:42:16 +00:00
|
|
|
return allocator_type(__table_.__node_alloc());
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2024-09-12 21:18:43 +02:00
|
|
|
[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class... _Args>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
|
2011-06-30 21:18:19 +00:00
|
|
|
return __table_.__emplace_multi(std::forward<_Args>(__args)...);
|
|
|
|
|
}
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class... _Args>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
|
2011-06-30 21:18:19 +00:00
|
|
|
return __table_.__emplace_hint_multi(__p, std::forward<_Args>(__args)...);
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2011-06-30 21:18:19 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return __table_.__insert_multi(std::move(__x)); }
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x) {
|
2011-06-30 21:18:19 +00:00
|
|
|
return __table_.__insert_multi(__p, std::move(__x));
|
|
|
|
|
}
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2017-04-18 22:37:32 +00:00
|
|
|
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__insert_multi(__x); }
|
|
|
|
|
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x) {
|
|
|
|
|
return __table_.__insert_multi(__p, __x);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <_ContainerCompatibleRange<value_type> _Range>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
|
|
|
|
|
for (auto&& __element : __range) {
|
|
|
|
|
__table_.__insert_multi(std::forward<decltype(__element)>(__element));
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2018-08-01 01:33:38 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(node_type&& __nh) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
2018-08-01 01:33:38 +00:00
|
|
|
"node_type with incompatible allocator passed to unordered_multiset::insert()");
|
|
|
|
|
return __table_.template __node_handle_insert_multi<node_type>(std::move(__nh));
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
2018-08-01 01:33:38 +00:00
|
|
|
"node_type with incompatible allocator passed to unordered_multiset::insert()");
|
|
|
|
|
return __table_.template __node_handle_insert_multi<node_type>(__hint, std::move(__nh));
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __position) {
|
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__position);
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
|
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__key);
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2018-10-31 17:31:35 +00:00
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
|
}
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source) {
|
2023-07-20 10:13:54 -07:00
|
|
|
_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
|
|
|
|
|
__source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
|
2018-10-31 17:31:35 +00:00
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-08-01 01:33:38 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_multi(__k); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
|
|
|
|
|
return __table_.erase(__first, __last);
|
|
|
|
|
}
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2024-06-18 11:01:43 +02:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void swap(unordered_multiset& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
|
2011-06-04 20:18:37 +00:00
|
|
|
__table_.swap(__u.__table_);
|
|
|
|
|
}
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
|
|
|
|
|
return __table_.find(__k);
|
|
|
|
|
}
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
|
|
|
|
|
return __table_.find(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
|
|
|
|
|
return __table_.__count_multi(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
|
|
|
|
|
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
|
|
|
|
|
return find(__k) != end();
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2020-11-10 07:49:55 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
|
|
|
|
|
return __table_.__equal_range_multi(__k);
|
|
|
|
|
}
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
|
|
|
|
|
return __table_.__equal_range_multi(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
|
|
|
|
|
return __table_.__equal_range_multi(__k);
|
|
|
|
|
}
|
2024-05-08 10:34:55 +02:00
|
|
|
template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
|
2021-08-31 13:04:29 -04:00
|
|
|
_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
|
|
|
|
|
return __table_.__equal_range_multi(__k);
|
|
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_STD_VER >= 20
|
2010-05-11 19:42:16 +00:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2011-06-04 20:18:37 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
|
2022-07-10 11:41:02 +02:00
|
|
|
_LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_multi(__n); }
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_multi(__n); }
|
2010-05-11 19:42:16 +00:00
|
|
|
};
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Hash = hash<__iter_value_type<_InputIterator>>,
|
|
|
|
|
class _Pred = equal_to<__iter_value_type<_InputIterator>>,
|
|
|
|
|
class _Allocator = allocator<__iter_value_type<_InputIterator>>,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_multiset(
|
|
|
|
|
_InputIterator,
|
|
|
|
|
_InputIterator,
|
|
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
|
|
|
|
_Allocator = _Allocator()) -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2023-07-10 17:16:56 -07:00
|
|
|
template <ranges::input_range _Range,
|
|
|
|
|
class _Hash = hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
class _Pred = equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
class _Allocator = allocator<ranges::range_value_t<_Range>>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2010-05-11 19:42:16 +00:00
|
|
|
unordered_multiset(
|
2023-07-10 17:16:56 -07:00
|
|
|
from_range_t,
|
|
|
|
|
_Range&&,
|
|
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
|
|
|
|
_Allocator = _Allocator()) -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _Tp,
|
|
|
|
|
class _Hash = hash<_Tp>,
|
|
|
|
|
class _Pred = equal_to<_Tp>,
|
|
|
|
|
class _Allocator = allocator<_Tp>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Pred>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_multiset(initializer_list<_Tp>,
|
2023-07-10 17:16:56 -07:00
|
|
|
typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
|
_Hash = _Hash(),
|
|
|
|
|
_Pred = _Pred(),
|
2019-07-11 15:16:39 +00:00
|
|
|
_Allocator = _Allocator()) -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Allocator,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_multiset<__iter_value_type<_InputIterator>,
|
|
|
|
|
hash<__iter_value_type<_InputIterator>>,
|
|
|
|
|
equal_to<__iter_value_type<_InputIterator>>,
|
2023-07-10 17:16:56 -07:00
|
|
|
_Allocator>;
|
2023-12-18 14:01:33 -05:00
|
|
|
|
2019-07-11 15:16:39 +00:00
|
|
|
template <class _InputIterator,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
2023-05-17 10:34:51 -07:00
|
|
|
class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
|
2023-07-10 17:16:56 -07:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_multiset<__iter_value_type<_InputIterator>,
|
|
|
|
|
_Hash,
|
|
|
|
|
equal_to<__iter_value_type<_InputIterator>>,
|
|
|
|
|
_Allocator>;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 23
|
2019-07-11 15:16:39 +00:00
|
|
|
|
2023-07-10 17:16:56 -07:00
|
|
|
template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<_Range>,
|
|
|
|
|
hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
_Allocator>;
|
|
|
|
|
|
|
|
|
|
template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_multiset(from_range_t, _Range&&, _Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<_Range>,
|
|
|
|
|
hash<ranges::range_value_t<_Range>>,
|
|
|
|
|
equal_to<ranges::range_value_t<_Range>>,
|
|
|
|
|
_Allocator>;
|
|
|
|
|
|
|
|
|
|
template <ranges::input_range _Range,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
|
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
|
|
|
|
unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_multiset<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-07-10 17:16:56 -07:00
|
|
|
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
|
-> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
|
|
|
|
|
|
|
|
|
|
template <class _Tp,
|
|
|
|
|
class _Hash,
|
|
|
|
|
class _Allocator,
|
[libc++] Use enable_if_t instead of _EnableIf
I just ran into a compiler error involving __bind_back and some overloads
that were being disabled with _EnableIf. I noticed that the error message
was quite bad and did not mention the reason for the overload being
excluded. Specifically, the error looked like this:
candidate template ignored: substitution failure [with _Args =
<ContiguousView>]: no member named '_EnableIfImpl' in 'std::_MetaBase<false>'
Instead, when using enable_if or enable_if_t, the compiler is clever and
can produce better diagnostics, like so:
candidate template ignored: requirement 'is_invocable_v<
std::__bind_back_op<1, std::integer_sequence<unsigned long, 0>>,
std::ranges::views::__transform::__fn &, std::tuple<PlusOne> &,
ContiguousView>' was not satisfied [with _Args = <ContiguousView>]
Basically, it tries to do a poor man's implementation of concepts, which
is already a lot better than simply complaining about substitution failure.
Hence, this commit uses enable_if_t instead of _EnableIf whenever
possible. That is both more straightforward than using the internal
helper, and also leads to better error messages in those cases.
I understand the motivation for _EnableIf's implementation was to improve
compile-time performance, however I believe striving to improve error
messages is even more important for our QOI, hence this patch. Furthermore,
it is unclear that _EnableIf actually improved compile-time performance
in any noticeable way (see discussion in the review for details).
Differential Revision: https://reviews.llvm.org/D108216
2021-08-17 12:26:09 -04:00
|
|
|
class = enable_if_t<!__is_allocator<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<!is_integral<_Hash>::value>,
|
|
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-11 15:16:39 +00:00
|
|
|
unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
|
-> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2019-07-11 15:16:39 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(_InputIterator __first, _InputIterator __last) {
|
|
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
_InputIterator __first,
|
|
|
|
|
_InputIterator __last,
|
|
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__first, __last);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const allocator_type& __a)
|
|
|
|
|
: __table_(__a) {}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const unordered_multiset& __u)
|
|
|
|
|
: __table_(__u.__table_) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__u.bucket_count());
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
const unordered_multiset& __u, const allocator_type& __a)
|
|
|
|
|
: __table_(__u.__table_, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__u.bucket_count());
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(unordered_multiset&& __u)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
|
2011-06-30 21:18:19 +00:00
|
|
|
: __table_(std::move(__u.__table_)) {}
|
2010-05-11 19:42:16 +00:00
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
unordered_multiset&& __u, const allocator_type& __a)
|
2011-06-30 21:18:19 +00:00
|
|
|
: __table_(std::move(__u.__table_), __a) {
|
2010-05-11 19:42:16 +00:00
|
|
|
if (__a != __u.get_allocator()) {
|
|
|
|
|
iterator __i = __u.begin();
|
|
|
|
|
while (__u.size() != 0)
|
2023-10-12 20:13:08 -07:00
|
|
|
__table_.__insert_multi(std::move(__u.__table_.remove(__i++)->__get_value()));
|
2010-05-11 19:42:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(initializer_list<value_type> __il) {
|
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
|
: __table_(__hf, __eql) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
|
|
|
|
|
initializer_list<value_type> __il,
|
|
|
|
|
size_type __n,
|
|
|
|
|
const hasher& __hf,
|
|
|
|
|
const key_equal& __eql,
|
|
|
|
|
const allocator_type& __a)
|
|
|
|
|
: __table_(__hf, __eql, __a) {
|
2022-07-10 11:41:02 +02:00
|
|
|
__table_.__rehash_multi(__n);
|
2010-05-11 19:42:16 +00:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_multiset&& __u)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
|
2011-06-30 21:18:19 +00:00
|
|
|
__table_ = std::move(__u.__table_);
|
2010-05-11 19:42:16 +00:00
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
|
|
|
|
|
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
|
|
|
|
|
__table_.__assign_multi(__il.begin(), __il.end());
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
2011-08-12 21:56:02 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
template <class _InputIterator>
|
|
|
|
|
inline void unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
|
|
|
|
|
for (; __first != __last; ++__first)
|
|
|
|
|
__table_.__insert_multi(*__first);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
2010-09-23 18:58:28 +00:00
|
|
|
inline _LIBCPP_HIDE_FROM_ABI void
|
2010-05-11 19:42:16 +00:00
|
|
|
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
|
2011-06-04 20:18:37 +00:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
|
2010-05-11 19:42:16 +00:00
|
|
|
__x.swap(__y);
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 20
|
2020-05-02 13:58:03 +02:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
|
|
|
|
|
erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
|
2021-03-21 16:53:09 -04:00
|
|
|
return std::__libcpp_erase_if_container(__c, __pred);
|
2020-05-02 13:58:03 +02:00
|
|
|
}
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2018-12-14 18:49:35 +00:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
|
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
|
|
|
|
|
if (__x.size() != __y.size())
|
|
|
|
|
return false;
|
|
|
|
|
typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
|
|
|
|
|
typedef pair<const_iterator, const_iterator> _EqRng;
|
|
|
|
|
for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) {
|
|
|
|
|
_EqRng __xeq = __x.equal_range(*__i);
|
|
|
|
|
_EqRng __yeq = __y.equal_range(*__i);
|
2011-06-30 21:18:19 +00:00
|
|
|
if (std::distance(__xeq.first, __xeq.second) != std::distance(__yeq.first, __yeq.second) ||
|
|
|
|
|
!std::is_permutation(__xeq.first, __xeq.second, __yeq.first))
|
2010-05-11 19:42:16 +00:00
|
|
|
return false;
|
|
|
|
|
__i = __xeq.second;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER <= 17
|
2023-06-11 08:39:49 +03:00
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
|
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
|
|
|
|
|
return !(__x == __y);
|
|
|
|
|
}
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2023-06-11 08:39:49 +03:00
|
|
|
|
2024-10-12 18:29:59 +01:00
|
|
|
template <class _Value, class _Hash, class _Pred, class _Alloc>
|
|
|
|
|
struct __container_traits<unordered_multiset<_Value, _Hash, _Pred, _Alloc> > {
|
|
|
|
|
// http://eel.is/c++draft/unord.req.except#2
|
|
|
|
|
// For unordered associative containers, if an exception is thrown by any operation
|
|
|
|
|
// other than the container's hash function from within an insert or emplace function
|
|
|
|
|
// inserting a single element, the insertion has no effect.
|
|
|
|
|
static _LIBCPP_CONSTEXPR const bool __emplacement_has_strong_exception_safety_guarantee =
|
2025-01-20 18:00:15 +01:00
|
|
|
__is_nothrow_invocable_v<_Hash, const _Value&>;
|
2024-10-12 18:29:59 +01:00
|
|
|
};
|
|
|
|
|
|
2010-05-11 19:42:16 +00:00
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if _LIBCPP_STD_VER >= 17
|
2022-10-06 16:53:30 -04:00
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
namespace pmr {
|
|
|
|
|
template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
|
2023-03-29 16:48:20 -04:00
|
|
|
using unordered_set _LIBCPP_AVAILABILITY_PMR = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
|
2022-10-06 16:53:30 -04:00
|
|
|
|
|
|
|
|
template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
|
2023-03-29 16:48:20 -04:00
|
|
|
using unordered_multiset _LIBCPP_AVAILABILITY_PMR =
|
|
|
|
|
std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
|
2022-10-06 16:53:30 -04:00
|
|
|
} // namespace pmr
|
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
2024-12-10 16:02:12 +01:00
|
|
|
# endif
|
2022-10-06 16:53:30 -04:00
|
|
|
|
[libc++] Fix missing and incorrect push/pop macros (#79204)
We recently noticed that the unwrap_iter.h file was pushing macros, but
it was pushing them again instead of popping them at the end of the
file. This led to libc++ basically swallowing any custom definition of
these macros in user code:
#define min HELLO
#include <algorithm>
// min is not HELLO anymore, it's not defined
While investigating this issue, I noticed that our push/pop pragmas were
actually entirely wrong too. Indeed, instead of pushing macros like
`move`, we'd push `move(int, int)` in the pragma, which is not a valid
macro name. As a result, we would not actually push macros like `move`
-- instead we'd simply undefine them. This led to the following code not
working:
#define move HELLO
#include <algorithm>
// move is not HELLO anymore
Fixing the pragma push/pop incantations led to a cascade of issues
because we use identifiers like `move` in a large number of places, and
all of these headers would now need to do the push/pop dance.
This patch fixes all these issues. First, it adds a check that we don't
swallow important names like min, max, move or refresh as explained
above. This is done by augmenting the existing
system_reserved_names.gen.py test to also check that the macros are what
we expect after including each header.
Second, it fixes the push/pop pragmas to work properly and adds missing
pragmas to all the files I could detect a failure in via the newly added
test.
rdar://121365472
2024-01-25 15:48:46 -05:00
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
|
|
2024-12-10 16:02:12 +01:00
|
|
|
# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
|
|
|
|
# include <cmath>
|
|
|
|
|
# include <concepts>
|
|
|
|
|
# include <cstdlib>
|
|
|
|
|
# include <functional>
|
|
|
|
|
# include <iterator>
|
|
|
|
|
# include <stdexcept>
|
|
|
|
|
# include <type_traits>
|
|
|
|
|
# endif
|
2024-12-21 13:01:48 +01:00
|
|
|
#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
2022-09-02 17:53:28 +02:00
|
|
|
|
2021-04-20 12:03:32 -04:00
|
|
|
#endif // _LIBCPP_UNORDERED_SET
|