2010-05-12 03:42:16 +08:00
|
|
|
// -*- C++ -*-
|
2021-11-18 05:25:01 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
2019-01-19 18:56:40 +08: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-12 03:42:16 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef _LIBCPP_UNORDERED_MAP
|
|
|
|
#define _LIBCPP_UNORDERED_MAP
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
unordered_map synopsis
|
|
|
|
|
|
|
|
#include <initializer_list>
|
|
|
|
|
|
|
|
namespace std
|
|
|
|
{
|
|
|
|
|
|
|
|
template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
|
|
|
class Alloc = allocator<pair<const Key, T>>>
|
|
|
|
class unordered_map
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types
|
|
|
|
typedef Key key_type;
|
|
|
|
typedef T mapped_type;
|
|
|
|
typedef Hash hasher;
|
|
|
|
typedef Pred key_equal;
|
|
|
|
typedef Alloc allocator_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_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 09:33:38 +08:00
|
|
|
typedef unspecified node_type; // C++17
|
|
|
|
typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type; // C++17
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map()
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_default_constructible<hasher>::value &&
|
|
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
|
|
|
explicit unordered_map(size_type n, const hasher& hf = hasher(),
|
2010-05-12 03:42:16 +08:00
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
template <class InputIterator>
|
|
|
|
unordered_map(InputIterator f, InputIterator l,
|
|
|
|
size_type n = 0, const hasher& hf = hasher(),
|
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
explicit unordered_map(const allocator_type&);
|
|
|
|
unordered_map(const unordered_map&);
|
|
|
|
unordered_map(const unordered_map&, const Allocator&);
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map(unordered_map&&)
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_move_constructible<hasher>::value &&
|
|
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map(unordered_map&&, const Allocator&);
|
|
|
|
unordered_map(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-12 11:00:31 +08:00
|
|
|
unordered_map(size_type n, const allocator_type& a)
|
|
|
|
: unordered_map(n, hasher(), key_equal(), a) {} // C++14
|
|
|
|
unordered_map(size_type n, const hasher& hf, const allocator_type& a)
|
|
|
|
: unordered_map(n, hf, key_equal(), a) {} // C++14
|
|
|
|
template <class InputIterator>
|
|
|
|
unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
|
|
|
|
: unordered_map(f, l, n, hasher(), key_equal(), a) {} // C++14
|
|
|
|
template <class InputIterator>
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& a)
|
|
|
|
: unordered_map(f, l, n, hf, key_equal(), a) {} // C++14
|
|
|
|
unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
|
|
|
|
: unordered_map(il, n, hasher(), key_equal(), a) {} // C++14
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& a)
|
|
|
|
: unordered_map(il, n, hf, key_equal(), a) {} // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
~unordered_map();
|
|
|
|
unordered_map& operator=(const unordered_map&);
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map& operator=(unordered_map&&)
|
|
|
|
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-12 03:42:16 +08:00
|
|
|
unordered_map& operator=(initializer_list<value_type>);
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
bool empty() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-05 02:54:24 +08: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-12 03:42:16 +08: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);
|
|
|
|
template <class P>
|
|
|
|
pair<iterator, bool> insert(P&& obj);
|
|
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
|
|
|
template <class P>
|
|
|
|
iterator insert(const_iterator hint, P&& obj);
|
|
|
|
template <class InputIterator>
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
|
|
|
void insert(initializer_list<value_type>);
|
|
|
|
|
2018-08-01 09:33:38 +08: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
|
|
|
|
|
2015-07-07 13:45:35 +08:00
|
|
|
template <class... Args>
|
|
|
|
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17
|
|
|
|
template <class M>
|
|
|
|
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-05 02:54:24 +08:00
|
|
|
void clear() noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_map<Key, T, H2, P2, Allocator>& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_map<Key, T, H2, P2, Allocator>&& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
void swap(unordered_map&)
|
|
|
|
noexcept(
|
|
|
|
(!allocator_type::propagate_on_container_swap::value ||
|
|
|
|
__is_nothrow_swappable<allocator_type>::value) &&
|
|
|
|
__is_nothrow_swappable<hasher>::value &&
|
|
|
|
__is_nothrow_swappable<key_equal>::value);
|
2010-05-12 03:42:16 +08: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 20:49:55 +08: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-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& k) const;
|
2020-11-10 20:49:55 +08:00
|
|
|
template<typename K>
|
|
|
|
size_type count(const K& k) const; // C++20
|
2019-07-16 11:21:01 +08:00
|
|
|
bool contains(const key_type& k) const; // C++20
|
2020-11-10 20:49:55 +08:00
|
|
|
template<typename K>
|
|
|
|
bool contains(const K& k) const; // C++20
|
2010-05-12 03:42:16 +08: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 20:49:55 +08: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-12 03:42:16 +08:00
|
|
|
|
|
|
|
mapped_type& operator[](const key_type& k);
|
|
|
|
mapped_type& operator[](key_type&& k);
|
|
|
|
|
|
|
|
mapped_type& at(const key_type& k);
|
|
|
|
const mapped_type& at(const key_type& k) const;
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type bucket_count() const noexcept;
|
|
|
|
size_type max_bucket_count() const noexcept;
|
2010-05-12 03:42:16 +08: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-05 02:54:24 +08:00
|
|
|
float load_factor() const noexcept;
|
|
|
|
float max_load_factor() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
void max_load_factor(float z);
|
|
|
|
void rehash(size_type n);
|
|
|
|
void reserve(size_type n);
|
|
|
|
};
|
|
|
|
|
2021-11-10 01:21:02 +08:00
|
|
|
template<class InputIterator,
|
|
|
|
class Hash = hash<iter_key_t<InputIterator>>, class Pred = equal_to<iter_key_t<InputIterator>>,
|
|
|
|
class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
|
|
|
|
unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
-> unordered_map<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
|
|
|
|
Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, class Hash = hash<Key>,
|
|
|
|
class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
|
|
|
|
unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
-> unordered_map<Key, T, Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator)
|
|
|
|
-> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
|
|
|
|
hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
unordered_map(InputIterator, InputIterator, Allocator)
|
|
|
|
-> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
|
|
|
|
hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Hash, class Allocator>
|
|
|
|
unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
|
|
|
|
-> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
|
|
|
|
equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, typename Allocator>
|
|
|
|
unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
|
|
|
|
-> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, typename Allocator>
|
|
|
|
unordered_map(initializer_list<pair<const Key, T>>, Allocator)
|
|
|
|
-> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, class Hash, class Allocator>
|
|
|
|
unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Hash, Allocator)
|
|
|
|
-> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map<Key, T, Hash, Pred, Alloc>& y)
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
bool
|
|
|
|
operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
|
|
|
|
const unordered_map<Key, T, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
bool
|
|
|
|
operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
|
|
|
|
const unordered_map<Key, T, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
|
|
|
class Alloc = allocator<pair<const Key, T>>>
|
|
|
|
class unordered_multimap
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types
|
|
|
|
typedef Key key_type;
|
|
|
|
typedef T mapped_type;
|
|
|
|
typedef Hash hasher;
|
|
|
|
typedef Pred key_equal;
|
|
|
|
typedef Alloc allocator_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_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 09:33:38 +08:00
|
|
|
typedef unspecified node_type; // C++17
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap()
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_default_constructible<hasher>::value &&
|
|
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
|
|
|
explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
|
2010-05-12 03:42:16 +08:00
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
template <class InputIterator>
|
|
|
|
unordered_multimap(InputIterator f, InputIterator l,
|
|
|
|
size_type n = 0, const hasher& hf = hasher(),
|
|
|
|
const key_equal& eql = key_equal(),
|
|
|
|
const allocator_type& a = allocator_type());
|
|
|
|
explicit unordered_multimap(const allocator_type&);
|
|
|
|
unordered_multimap(const unordered_multimap&);
|
|
|
|
unordered_multimap(const unordered_multimap&, const Allocator&);
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap(unordered_multimap&&)
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_move_constructible<hasher>::value &&
|
|
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap(unordered_multimap&&, const Allocator&);
|
|
|
|
unordered_multimap(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-12 11:00:31 +08:00
|
|
|
unordered_multimap(size_type n, const allocator_type& a)
|
|
|
|
: unordered_multimap(n, hasher(), key_equal(), a) {} // C++14
|
|
|
|
unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
|
|
|
|
: unordered_multimap(n, hf, key_equal(), a) {} // C++14
|
|
|
|
template <class InputIterator>
|
|
|
|
unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
|
|
|
|
: unordered_multimap(f, l, n, hasher(), key_equal(), a) {} // C++14
|
|
|
|
template <class InputIterator>
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& a)
|
|
|
|
: unordered_multimap(f, l, n, hf, key_equal(), a) {} // C++14
|
|
|
|
unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
|
|
|
|
: unordered_multimap(il, n, hasher(), key_equal(), a) {} // C++14
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& a)
|
|
|
|
: unordered_multimap(il, n, hf, key_equal(), a) {} // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
~unordered_multimap();
|
|
|
|
unordered_multimap& operator=(const unordered_multimap&);
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap& operator=(unordered_multimap&&)
|
|
|
|
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-12 03:42:16 +08:00
|
|
|
unordered_multimap& operator=(initializer_list<value_type>);
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
bool empty() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-05 02:54:24 +08: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-12 03:42:16 +08: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);
|
|
|
|
template <class P>
|
|
|
|
iterator insert(P&& obj);
|
|
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
|
|
|
template <class P>
|
|
|
|
iterator insert(const_iterator hint, P&& obj);
|
|
|
|
template <class InputIterator>
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
|
|
|
void insert(initializer_list<value_type>);
|
|
|
|
|
2018-08-01 09:33:38 +08: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-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-05 02:54:24 +08:00
|
|
|
void clear() noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_map<Key, T, H2, P2, Allocator>& source); // C++17
|
|
|
|
template<class H2, class P2>
|
|
|
|
void merge(unordered_map<Key, T, H2, P2, Allocator>&& source); // C++17
|
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
void swap(unordered_multimap&)
|
|
|
|
noexcept(
|
|
|
|
(!allocator_type::propagate_on_container_swap::value ||
|
|
|
|
__is_nothrow_swappable<allocator_type>::value) &&
|
|
|
|
__is_nothrow_swappable<hasher>::value &&
|
|
|
|
__is_nothrow_swappable<key_equal>::value);
|
2010-05-12 03:42:16 +08: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 20:49:55 +08: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-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& k) const;
|
2020-11-10 20:49:55 +08:00
|
|
|
template<typename K>
|
|
|
|
size_type count(const K& k) const; // C++20
|
2019-07-16 11:21:01 +08:00
|
|
|
bool contains(const key_type& k) const; // C++20
|
2020-11-10 20:49:55 +08:00
|
|
|
template<typename K>
|
|
|
|
bool contains(const K& k) const; // C++20
|
2010-05-12 03:42:16 +08: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 20:49:55 +08: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-12 03:42:16 +08:00
|
|
|
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type bucket_count() const noexcept;
|
|
|
|
size_type max_bucket_count() const noexcept;
|
2010-05-12 03:42:16 +08: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-05 02:54:24 +08:00
|
|
|
float load_factor() const noexcept;
|
|
|
|
float max_load_factor() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
void max_load_factor(float z);
|
|
|
|
void rehash(size_type n);
|
|
|
|
void reserve(size_type n);
|
|
|
|
};
|
|
|
|
|
2021-11-10 01:21:02 +08:00
|
|
|
template<class InputIterator,
|
|
|
|
class Hash = hash<iter_key_t<InputIterator>>, class Pred = equal_to<iter_key_t<InputIterator>>,
|
|
|
|
class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
|
|
|
|
unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below,
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
-> unordered_multimap<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
|
|
|
|
Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, class Hash = hash<Key>,
|
|
|
|
class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
|
|
|
|
unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
|
|
|
|
Hash = Hash(), Pred = Pred(), Allocator = Allocator())
|
|
|
|
-> unordered_multimap<Key, T, Hash, Pred, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
|
|
|
|
-> unordered_multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
|
|
|
|
hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Allocator>
|
|
|
|
unordered_multimap(InputIterator, InputIterator, Allocator)
|
|
|
|
-> unordered_multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
|
|
|
|
hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class InputIterator, class Hash, class Allocator>
|
|
|
|
unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
|
|
|
|
-> unordered_multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
|
|
|
|
equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, typename Allocator>
|
|
|
|
unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
|
|
|
|
-> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, typename Allocator>
|
|
|
|
unordered_multimap(initializer_list<pair<const Key, T>>, Allocator)
|
|
|
|
-> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
|
|
|
template<class Key, class T, class Hash, class Allocator>
|
|
|
|
unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Hash,
|
|
|
|
Allocator)
|
|
|
|
-> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>; // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
template <class K, class T, class H, class P, class A, class Predicate>
|
2020-05-02 19:58:03 +08:00
|
|
|
typename unordered_map<K, T, H, P, A>::size_type
|
|
|
|
erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred); // C++20
|
2018-12-15 02:49:35 +08:00
|
|
|
|
|
|
|
template <class K, class T, class H, class P, class A, class Predicate>
|
2020-05-02 19:58:03 +08:00
|
|
|
typename unordered_multimap<K, T, H, P, A>::size_type
|
|
|
|
erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred); // C++20
|
2018-12-15 02:49:35 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
bool
|
|
|
|
operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
|
|
|
|
const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Hash, class Pred, class Alloc>
|
|
|
|
bool
|
|
|
|
operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
|
|
|
|
const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
|
|
|
|
|
|
|
|
} // std
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <__config>
|
2021-05-19 23:57:04 +08:00
|
|
|
#include <__debug>
|
2021-07-01 21:25:35 +08:00
|
|
|
#include <__functional/is_transparent.h>
|
2010-05-12 03:42:16 +08:00
|
|
|
#include <__hash_table>
|
2022-01-07 22:45:05 +08:00
|
|
|
#include <__iterator/iterator_traits.h>
|
2018-08-01 09:33:38 +08:00
|
|
|
#include <__node_handle>
|
2021-06-05 10:47:47 +08:00
|
|
|
#include <__utility/forward.h>
|
2021-03-25 06:19:12 +08:00
|
|
|
#include <compare>
|
2010-05-12 03:42:16 +08:00
|
|
|
#include <functional>
|
2021-03-22 04:53:09 +08:00
|
|
|
#include <iterator> // __libcpp_erase_if_container
|
2010-05-12 03:42:16 +08:00
|
|
|
#include <stdexcept>
|
2016-02-12 05:45:53 +08:00
|
|
|
#include <tuple>
|
2018-09-13 03:41:40 +08:00
|
|
|
#include <version>
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-10-18 04:05:10 +08:00
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
2010-05-12 03:42:16 +08:00
|
|
|
#pragma GCC system_header
|
2011-10-18 04:05:10 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Hash, class _Pred,
|
2018-12-07 05:46:17 +08:00
|
|
|
bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __unordered_map_hasher
|
|
|
|
: private _Hash
|
|
|
|
{
|
|
|
|
public:
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_hasher()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
|
|
|
|
: _Hash() {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_hasher(const _Hash& __h)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
|
|
|
|
: _Hash(__h) {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const _Hash& hash_function() const _NOEXCEPT {return *this;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-12-13 01:26:24 +08:00
|
|
|
size_t operator()(const _Cp& __x) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
|
2011-12-13 01:26:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
size_t operator()(const _Key& __x) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return static_cast<const _Hash&>(*this)(__x);}
|
2020-11-10 20:49:55 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
size_t operator()(const _K2& __x) const
|
|
|
|
{return static_cast<const _Hash&>(*this)(__x);}
|
|
|
|
#endif
|
2021-09-01 01:04:29 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2021-09-01 02:29:24 +08:00
|
|
|
void swap(__unordered_map_hasher& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
|
|
|
|
{
|
|
|
|
using _VSTD::swap;
|
2017-04-13 09:02:41 +08:00
|
|
|
swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
|
2015-07-14 04:04:56 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Hash, class _Pred>
|
|
|
|
class __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, false>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_Hash __hash_;
|
|
|
|
public:
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_hasher()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
|
|
|
|
: __hash_() {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_hasher(const _Hash& __h)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
|
|
|
|
: __hash_(__h) {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-12-13 01:26:24 +08:00
|
|
|
size_t operator()(const _Cp& __x) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return __hash_(__x.__get_value().first);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-12-13 01:26:24 +08:00
|
|
|
size_t operator()(const _Key& __x) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __hash_(__x);}
|
2020-11-10 20:49:55 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
size_t operator()(const _K2& __x) const
|
|
|
|
{return __hash_(__x);}
|
|
|
|
#endif
|
2021-09-01 01:04:29 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2021-09-01 02:29:24 +08:00
|
|
|
void swap(__unordered_map_hasher& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
|
|
|
|
{
|
|
|
|
using _VSTD::swap;
|
|
|
|
swap(__hash_, __y.__hash_);
|
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Hash, class _Pred, bool __b>
|
2015-07-14 04:04:56 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
void
|
2020-11-10 20:49:55 +08:00
|
|
|
swap(__unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __x,
|
|
|
|
__unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Pred, class _Hash,
|
2018-12-07 05:46:17 +08:00
|
|
|
bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __unordered_map_equal
|
|
|
|
: private _Pred
|
|
|
|
{
|
|
|
|
public:
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_equal()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
|
|
|
|
: _Pred() {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_equal(const _Pred& __p)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
|
|
|
|
: _Pred(__p) {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const _Pred& key_eq() const _NOEXCEPT {return *this;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-12-13 01:26:24 +08:00
|
|
|
bool operator()(const _Cp& __x, const _Cp& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
|
2011-12-13 01:26:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Cp& __x, const _Key& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
|
2011-12-13 01:26:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Key& __x, const _Cp& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
|
2020-11-10 20:49:55 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Cp& __x, const _K2& __y) const
|
|
|
|
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _K2& __x, const _Cp& __y) const
|
|
|
|
{return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Key& __x, const _K2& __y) const
|
|
|
|
{return static_cast<const _Pred&>(*this)(__x, __y);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _K2& __x, const _Key& __y) const
|
|
|
|
{return static_cast<const _Pred&>(*this)(__x, __y);}
|
|
|
|
#endif
|
2021-09-01 01:04:29 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2021-09-01 02:29:24 +08:00
|
|
|
void swap(__unordered_map_equal& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
|
|
|
|
{
|
|
|
|
using _VSTD::swap;
|
2017-04-13 09:02:41 +08:00
|
|
|
swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
|
2015-07-14 04:04:56 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Pred, class _Hash>
|
|
|
|
class __unordered_map_equal<_Key, _Cp, _Pred, _Hash, false>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_Pred __pred_;
|
|
|
|
public:
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_equal()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
|
|
|
|
: __pred_() {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__unordered_map_equal(const _Pred& __p)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
|
|
|
|
: __pred_(__p) {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const _Pred& key_eq() const _NOEXCEPT {return __pred_;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-12-13 01:26:24 +08:00
|
|
|
bool operator()(const _Cp& __x, const _Cp& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return __pred_(__x.__get_value().first, __y.__get_value().first);}
|
2011-12-13 01:26:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Cp& __x, const _Key& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return __pred_(__x.__get_value().first, __y);}
|
2011-12-13 01:26:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Key& __x, const _Cp& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return __pred_(__x, __y.__get_value().first);}
|
2020-11-10 20:49:55 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Cp& __x, const _K2& __y) const
|
|
|
|
{return __pred_(__x.__get_value().first, __y);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _K2& __x, const _Cp& __y) const
|
|
|
|
{return __pred_(__x, __y.__get_value().first);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Key& __x, const _K2& __y) const
|
|
|
|
{return __pred_(__x, __y);}
|
2021-09-01 01:04:29 +08:00
|
|
|
template <typename _K2>
|
2020-11-10 20:49:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _K2& __x, const _Key& __y) const
|
|
|
|
{return __pred_(__x, __y);}
|
|
|
|
#endif
|
2021-09-01 01:04:29 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2021-09-01 02:29:24 +08:00
|
|
|
void swap(__unordered_map_equal& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
|
|
|
|
{
|
|
|
|
using _VSTD::swap;
|
|
|
|
swap(__pred_, __y.__pred_);
|
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2020-11-10 20:49:55 +08:00
|
|
|
template <class _Key, class _Cp, class _Pred, class _Hash, bool __b>
|
2015-07-14 04:04:56 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
void
|
2020-11-10 20:49:55 +08:00
|
|
|
swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __x,
|
|
|
|
__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __y)
|
2015-07-14 04:04:56 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Alloc>
|
|
|
|
class __hash_map_node_destructor
|
|
|
|
{
|
|
|
|
typedef _Alloc allocator_type;
|
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
2016-02-11 04:46:23 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2016-02-11 04:46:23 +08:00
|
|
|
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
2010-05-12 03:42:16 +08:00
|
|
|
private:
|
|
|
|
|
|
|
|
allocator_type& __na_;
|
|
|
|
|
|
|
|
__hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
|
|
|
|
|
|
|
|
public:
|
|
|
|
bool __first_constructed;
|
|
|
|
bool __second_constructed;
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __na_(__na),
|
|
|
|
__first_constructed(false),
|
|
|
|
__second_constructed(false)
|
|
|
|
{}
|
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __na_(__x.__na_),
|
|
|
|
__first_constructed(__x.__value_constructed),
|
|
|
|
__second_constructed(__x.__value_constructed)
|
|
|
|
{
|
|
|
|
__x.__value_constructed = false;
|
|
|
|
}
|
2017-04-19 06:50:56 +08:00
|
|
|
#else // _LIBCPP_CXX03_LANG
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
|
|
|
|
: __na_(__x.__na_),
|
|
|
|
__first_constructed(__x.__value_constructed),
|
|
|
|
__second_constructed(__x.__value_constructed)
|
|
|
|
{
|
|
|
|
const_cast<bool&>(__x.__value_constructed) = false;
|
|
|
|
}
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
void operator()(pointer __p) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__second_constructed)
|
2018-06-05 04:38:23 +08:00
|
|
|
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__first_constructed)
|
2018-06-05 04:38:23 +08:00
|
|
|
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__p)
|
|
|
|
__alloc_traits::deallocate(__na_, __p, 1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2013-10-01 03:08:22 +08:00
|
|
|
template <class _Key, class _Tp>
|
2021-03-16 05:20:49 +08:00
|
|
|
struct _LIBCPP_STANDALONE_DEBUG __hash_value_type
|
2013-10-01 03:08:22 +08:00
|
|
|
{
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
2018-06-05 04:38:23 +08:00
|
|
|
typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
|
|
|
|
typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;
|
2013-10-01 03:08:22 +08:00
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
private:
|
2013-10-01 03:08:22 +08:00
|
|
|
value_type __cc;
|
2018-06-05 04:38:23 +08:00
|
|
|
|
|
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
value_type& __get_value()
|
|
|
|
{
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
return *_VSTD::launder(_VSTD::addressof(__cc));
|
|
|
|
#else
|
|
|
|
return __cc;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const value_type& __get_value() const
|
|
|
|
{
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
return *_VSTD::launder(_VSTD::addressof(__cc));
|
|
|
|
#else
|
|
|
|
return __cc;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__nc_ref_pair_type __ref()
|
|
|
|
{
|
|
|
|
value_type& __v = __get_value();
|
|
|
|
return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__nc_rref_pair_type __move()
|
|
|
|
{
|
|
|
|
value_type& __v = __get_value();
|
|
|
|
return __nc_rref_pair_type(
|
|
|
|
_VSTD::move(const_cast<key_type&>(__v.first)),
|
|
|
|
_VSTD::move(__v.second));
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__hash_value_type& operator=(const __hash_value_type& __v)
|
2018-06-05 04:38:23 +08:00
|
|
|
{
|
|
|
|
__ref() = __v.__get_value();
|
|
|
|
return *this;
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__hash_value_type& operator=(__hash_value_type&& __v)
|
2018-06-05 04:38:23 +08:00
|
|
|
{
|
|
|
|
__ref() = __v.__move();
|
|
|
|
return *this;
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
template <class _ValueTp,
|
|
|
|
class = typename enable_if<
|
|
|
|
__is_same_uncvref<_ValueTp, value_type>::value
|
|
|
|
>::type
|
|
|
|
>
|
2013-10-01 03:08:22 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
__hash_value_type& operator=(_ValueTp&& __v)
|
|
|
|
{
|
|
|
|
__ref() = _VSTD::forward<_ValueTp>(__v);
|
|
|
|
return *this;
|
2016-02-11 19:59:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
__hash_value_type(const __hash_value_type& __v) = delete;
|
|
|
|
__hash_value_type(__hash_value_type&& __v) = delete;
|
|
|
|
template <class ..._Args>
|
|
|
|
explicit __hash_value_type(_Args&& ...__args) = delete;
|
|
|
|
|
|
|
|
~__hash_value_type() = delete;
|
2013-10-01 03:08:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
template <class _Key, class _Tp>
|
|
|
|
struct __hash_value_type
|
|
|
|
{
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
private:
|
2013-10-01 03:08:22 +08:00
|
|
|
value_type __cc;
|
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
value_type& __get_value() { return __cc; }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const value_type& __get_value() const { return __cc; }
|
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
private:
|
|
|
|
~__hash_value_type();
|
2013-10-01 03:08:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _HashIterator>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_HashIterator __i_;
|
|
|
|
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
|
|
|
typedef forward_iterator_tag iterator_category;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type value_type;
|
|
|
|
typedef typename _NodeTypes::difference_type difference_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef value_type& reference;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type_pointer pointer;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__hash_map_iterator() _NOEXCEPT {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
reference operator*() const {return __i_->__get_value();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_iterator& operator++() {++__i_; return *this;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_iterator operator++(int)
|
|
|
|
{
|
|
|
|
__hash_map_iterator __t(*this);
|
|
|
|
++(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ == __y.__i_;}
|
2010-09-24 02:58:28 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ != __y.__i_;}
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
|
|
|
|
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class _HashIterator>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_HashIterator __i_;
|
|
|
|
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
|
|
|
typedef forward_iterator_tag iterator_category;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type value_type;
|
|
|
|
typedef typename _NodeTypes::difference_type difference_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef const value_type& reference;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename _NodeTypes::__const_map_value_type_pointer pointer;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__hash_map_const_iterator() _NOEXCEPT {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
__hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_const_iterator(
|
|
|
|
__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __i_(__i.__i_) {}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
reference operator*() const {return __i_->__get_value();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_const_iterator& operator++() {++__i_; return *this;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__hash_map_const_iterator operator++(int)
|
|
|
|
{
|
|
|
|
__hash_map_const_iterator __t(*this);
|
|
|
|
++(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ == __y.__i_;}
|
2010-09-24 02:58:28 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ != __y.__i_;}
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
|
|
|
|
template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
class unordered_multimap;
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
|
|
|
|
class _Alloc = allocator<pair<const _Key, _Tp> > >
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS unordered_map
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
2021-03-04 00:10:49 +08:00
|
|
|
typedef __identity_t<_Hash> hasher;
|
|
|
|
typedef __identity_t<_Pred> key_equal;
|
|
|
|
typedef __identity_t<_Alloc> allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
|
|
|
typedef value_type& reference;
|
|
|
|
typedef const value_type& const_reference;
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
static_assert((is_same<value_type, typename allocator_type::value_type>::value),
|
|
|
|
"Invalid allocator::value_type");
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
private:
|
2020-11-10 20:49:55 +08:00
|
|
|
typedef __hash_value_type<key_type, mapped_type> __value_type;
|
|
|
|
typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
|
|
|
|
typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher> __key_equal;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
|
2020-11-10 20:49:55 +08:00
|
|
|
__value_type>::type __allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
typedef __hash_table<__value_type, __hasher,
|
|
|
|
__key_equal, __allocator_type> __table;
|
|
|
|
|
|
|
|
__table __table_;
|
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
typedef typename __table::_NodeTypes _NodeTypes;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename __table::__node_pointer __node_pointer;
|
|
|
|
typedef typename __table::__node_const_pointer __node_const_pointer;
|
|
|
|
typedef typename __table::__node_traits __node_traits;
|
|
|
|
typedef typename __table::__node_allocator __node_allocator;
|
|
|
|
typedef typename __table::__node __node;
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __hash_map_node_destructor<__node_allocator> _Dp;
|
|
|
|
typedef unique_ptr<__node, _Dp> __node_holder;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
2016-02-11 19:59:44 +08:00
|
|
|
|
|
|
|
static_assert((is_same<typename __table::__container_value_type, value_type>::value), "");
|
|
|
|
static_assert((is_same<typename __table::__node_value_type, __value_type>::value), "");
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
|
|
typedef typename __alloc_traits::const_pointer const_pointer;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename __table::size_type size_type;
|
|
|
|
typedef typename __table::difference_type difference_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
typedef __hash_map_iterator<typename __table::iterator> iterator;
|
|
|
|
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
|
|
|
|
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
|
|
|
|
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
|
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
typedef __map_node_handle<__node, allocator_type> node_type;
|
|
|
|
typedef __insert_return_type<iterator, node_type> insert_return_type;
|
|
|
|
#endif
|
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS unordered_map;
|
|
|
|
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
|
2022-01-11 07:33:35 +08:00
|
|
|
{
|
|
|
|
_VSTD::__debug_db_insert_c(this);
|
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit unordered_map(size_type __n, const hasher& __hf = hasher(),
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
unordered_map(size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map(_InputIterator __first, _InputIterator __last);
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map(_InputIterator __first, _InputIterator __last,
|
|
|
|
size_type __n, const hasher& __hf = hasher(),
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map(_InputIterator __first, _InputIterator __last,
|
|
|
|
size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit unordered_map(const allocator_type& __a);
|
|
|
|
unordered_map(const unordered_map& __u);
|
|
|
|
unordered_map(const unordered_map& __u, const allocator_type& __a);
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map(unordered_map&& __u)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map(unordered_map&& __u, const allocator_type& __a);
|
|
|
|
unordered_map(initializer_list<value_type> __il);
|
|
|
|
unordered_map(initializer_list<value_type> __il, size_type __n,
|
|
|
|
const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
|
|
|
|
unordered_map(initializer_list<value_type> __il, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2013-09-12 11:00:31 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_map(size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_map(__n, hasher(), key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
: unordered_map(__n, __hf, key_equal(), __a) {}
|
|
|
|
template <class _InputIterator>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_map(__first, __last, __n, hasher(), key_equal(), __a) {}
|
|
|
|
template <class _InputIterator>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& __a)
|
|
|
|
: unordered_map(__first, __last, __n, __hf, key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_map(__il, __n, hasher(), key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& __a)
|
|
|
|
: unordered_map(__il, __n, __hf, key_equal(), __a) {}
|
|
|
|
#endif
|
[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-12 00:14:56 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
~unordered_map() {
|
|
|
|
static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
|
|
|
|
}
|
|
|
|
|
2011-07-02 03:24:36 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_map& operator=(const unordered_map& __u)
|
|
|
|
{
|
2016-07-18 21:19:00 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2011-07-02 03:24:36 +08:00
|
|
|
__table_ = __u.__table_;
|
2013-06-22 23:21:29 +08:00
|
|
|
#else
|
2021-09-29 01:15:18 +08:00
|
|
|
if (this != _VSTD::addressof(__u)) {
|
2014-02-08 12:03:14 +08:00
|
|
|
__table_.clear();
|
|
|
|
__table_.hash_function() = __u.__table_.hash_function();
|
|
|
|
__table_.key_eq() = __u.__table_.key_eq();
|
|
|
|
__table_.max_load_factor() = __u.__table_.max_load_factor();
|
|
|
|
__table_.__copy_assign_alloc(__u.__table_);
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
2013-06-22 23:21:29 +08:00
|
|
|
#endif
|
2011-07-02 03:24:36 +08:00
|
|
|
return *this;
|
|
|
|
}
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_map& operator=(unordered_map&& __u)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map& operator=(initializer_list<value_type> __il);
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
allocator_type get_allocator() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{return allocator_type(__table_.__node_alloc());}
|
|
|
|
|
2017-11-15 13:51:26 +08:00
|
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
bool empty() const _NOEXCEPT {return __table_.size() == 0;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type size() const _NOEXCEPT {return __table_.size();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type max_size() const _NOEXCEPT {return __table_.max_size();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
iterator begin() _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
iterator end() _NOEXCEPT {return __table_.end();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator begin() const _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator end() const _NOEXCEPT {return __table_.end();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator cend() const _NOEXCEPT {return __table_.end();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-04-18 09:40:45 +08:00
|
|
|
pair<iterator, bool> insert(const value_type& __x)
|
|
|
|
{return __table_.__insert_unique(__x);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-04-18 09:40:45 +08:00
|
|
|
iterator insert(const_iterator __p, const value_type& __x) {
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2016-02-11 19:59:44 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
|
2016-04-18 09:40:45 +08:00
|
|
|
"unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
|
2016-02-11 19:59:44 +08:00
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__p);
|
2013-07-31 05:04:42 +08:00
|
|
|
#endif
|
2016-04-18 09:40:45 +08:00
|
|
|
return insert(__x).first;
|
2016-02-11 19:59:44 +08:00
|
|
|
}
|
|
|
|
|
2016-04-18 09:40:45 +08:00
|
|
|
template <class _InputIterator>
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-04-18 09:40:45 +08:00
|
|
|
void insert(_InputIterator __first, _InputIterator __last);
|
2016-02-11 19:59:44 +08:00
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-04-18 09:40:45 +08:00
|
|
|
void insert(initializer_list<value_type> __il)
|
|
|
|
{insert(__il.begin(), __il.end());}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> insert(value_type&& __x)
|
|
|
|
{return __table_.__insert_unique(_VSTD::move(__x));}
|
|
|
|
|
|
|
|
iterator insert(const_iterator __p, value_type&& __x) {
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2016-04-18 09:40:45 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
|
|
|
|
"unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
|
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__p);
|
2016-04-18 09:40:45 +08:00
|
|
|
#endif
|
|
|
|
return __table_.__insert_unique(_VSTD::move(__x)).first;
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
pair<iterator, bool> insert(_Pp&& __x)
|
|
|
|
{return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));}
|
2016-04-18 09:40:45 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-07-31 05:04:42 +08:00
|
|
|
iterator insert(const_iterator __p, _Pp&& __x)
|
|
|
|
{
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2013-07-31 05:04:42 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
|
|
|
|
"unordered_map::insert(const_iterator, value_type&&) called with an iterator not"
|
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__p);
|
2016-04-18 09:40:45 +08:00
|
|
|
#endif
|
2013-07-31 05:04:42 +08:00
|
|
|
return insert(_VSTD::forward<_Pp>(__x)).first;
|
|
|
|
}
|
2016-04-18 09:40:45 +08:00
|
|
|
|
|
|
|
template <class... _Args>
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-04-18 09:40:45 +08:00
|
|
|
pair<iterator, bool> emplace(_Args&&... __args) {
|
|
|
|
return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator emplace_hint(const_iterator __p, _Args&&... __args) {
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2016-04-18 09:40:45 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
|
|
|
|
"unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
|
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__p);
|
2016-04-18 09:40:45 +08:00
|
|
|
#endif
|
|
|
|
return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2015-07-07 13:45:35 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
|
|
|
|
{
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
return __table_.__emplace_unique_key_args(__k, piecewise_construct,
|
2016-04-18 14:51:33 +08:00
|
|
|
_VSTD::forward_as_tuple(__k),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
|
|
|
|
{
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
return __table_.__emplace_unique_key_args(__k, piecewise_construct,
|
2016-04-18 14:51:33 +08:00
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__k)),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
|
|
|
|
{
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2016-09-27 05:39:38 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__h) == this,
|
2016-04-18 14:51:33 +08:00
|
|
|
"unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
|
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__h);
|
2016-04-18 14:51:33 +08:00
|
|
|
#endif
|
2016-12-24 07:37:52 +08:00
|
|
|
return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
|
|
|
|
{
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2016-09-27 05:39:38 +08:00
|
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__h) == this,
|
2016-04-18 14:51:33 +08:00
|
|
|
"unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
|
|
|
|
" referring to this unordered_map");
|
2016-12-24 07:37:52 +08:00
|
|
|
#else
|
|
|
|
((void)__h);
|
2016-04-18 14:51:33 +08:00
|
|
|
#endif
|
|
|
|
return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
|
|
|
|
{
|
2016-04-18 14:51:33 +08:00
|
|
|
pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
|
|
|
|
__k, _VSTD::forward<_Vp>(__v));
|
|
|
|
if (!__res.second) {
|
|
|
|
__res.first->second = _VSTD::forward<_Vp>(__v);
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
2016-04-18 14:51:33 +08:00
|
|
|
return __res;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
2016-04-18 14:51:33 +08:00
|
|
|
|
2015-07-07 13:45:35 +08:00
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
|
|
|
|
{
|
2016-04-18 14:51:33 +08:00
|
|
|
pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
|
|
|
|
_VSTD::move(__k), _VSTD::forward<_Vp>(__v));
|
|
|
|
if (!__res.second) {
|
|
|
|
__res.first->second = _VSTD::forward<_Vp>(__v);
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
2016-04-18 14:51:33 +08:00
|
|
|
return __res;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-12-24 07:37:52 +08:00
|
|
|
iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v)
|
2015-07-07 13:45:35 +08:00
|
|
|
{
|
2016-12-24 07:37:52 +08:00
|
|
|
// FIXME: Add debug mode checking for the iterator input
|
2016-04-18 14:51:33 +08:00
|
|
|
return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-12-24 07:37:52 +08:00
|
|
|
iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v)
|
2015-07-07 13:45:35 +08:00
|
|
|
{
|
2016-12-24 07:37:52 +08:00
|
|
|
// FIXME: Add debug mode checking for the iterator input
|
2016-04-18 14:51:33 +08:00
|
|
|
return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
|
2015-07-07 13:45:35 +08:00
|
|
|
}
|
2017-04-19 06:50:56 +08:00
|
|
|
#endif // _LIBCPP_STD_VER > 14
|
2015-07-07 13:45:35 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator __p) {return __table_.erase(__p.__i_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __first, const_iterator __last)
|
|
|
|
{return __table_.erase(__first.__i_, __last.__i_);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-08-01 09:33:38 +08:00
|
|
|
void clear() _NOEXCEPT {__table_.clear();}
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
insert_return_type insert(node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to unordered_map::insert()");
|
|
|
|
return __table_.template __node_handle_insert_unique<
|
|
|
|
node_type, insert_return_type>(_VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __hint, node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to unordered_map::insert()");
|
|
|
|
return __table_.template __node_handle_insert_unique<node_type>(
|
|
|
|
__hint.__i_, _VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(key_type const& __key)
|
|
|
|
{
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__key);
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(const_iterator __it)
|
|
|
|
{
|
|
|
|
return __table_.template __node_handle_extract<node_type>(
|
|
|
|
__it.__i_);
|
|
|
|
}
|
2018-11-01 01:31:35 +08:00
|
|
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_unique(__source.__table_);
|
|
|
|
}
|
2018-08-01 09:33:38 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
void swap(unordered_map& __u)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<__table>::value)
|
2016-12-28 13:53:01 +08:00
|
|
|
{ __table_.swap(__u.__table_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
hasher hash_function() const
|
|
|
|
{return __table_.hash_function().hash_function();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
key_equal key_eq() const
|
|
|
|
{return __table_.key_eq().key_eq();}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator find(const key_type& __k) {return __table_.find(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator find(const _K2& __k) {return __table_.find(__k);}
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const_iterator find(const _K2& __k) const {return __table_.find(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
2020-11-10 20:49:55 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
size_type count(const _K2& __k) const {return __table_.__count_unique(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const key_type& __k) const {return find(__k) != end();}
|
|
|
|
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const _K2& __k) const {return find(__k) != end();}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
2020-11-10 20:49:55 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator, iterator> equal_range(const key_type& __k)
|
|
|
|
{return __table_.__equal_range_unique(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
|
|
|
|
{return __table_.__equal_range_unique(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, iterator> equal_range(const _K2& __k)
|
|
|
|
{return __table_.__equal_range_unique(__k);}
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
|
|
|
|
{return __table_.__equal_range_unique(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
mapped_type& operator[](const key_type& __k);
|
2016-02-12 05:45:53 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
mapped_type& operator[](key_type&& __k);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
mapped_type& at(const key_type& __k);
|
|
|
|
const mapped_type& at(const key_type& __k) const;
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type bucket_size(size_type __n) const
|
|
|
|
{return __table_.bucket_size(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
local_iterator begin(size_type __n) {return __table_.begin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
local_iterator end(size_type __n) {return __table_.end(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
float load_factor() const _NOEXCEPT {return __table_.load_factor();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void rehash(size_type __n) {__table_.rehash(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void reserve(size_type __n) {__table_.reserve(__n);}
|
|
|
|
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
|
|
|
bool __dereferenceable(const const_iterator* __i) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __decrementable(const const_iterator* __i) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __addable(const const_iterator* __i, ptrdiff_t __n) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_DEBUG_LEVEL == 2
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
private:
|
2016-02-12 05:45:53 +08:00
|
|
|
|
|
|
|
#ifdef _LIBCPP_CXX03_LANG
|
2013-07-05 04:59:16 +08:00
|
|
|
__node_holder __construct_node_with_key(const key_type& __k);
|
2016-02-12 05:45:53 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2021-08-17 23:59:07 +08:00
|
|
|
#if _LIBCPP_STD_VER >= 17
|
2019-07-16 04:06:01 +08:00
|
|
|
template<class _InputIterator,
|
|
|
|
class _Hash = hash<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Pred = equal_to<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
_Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
|
|
|
|
-> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
|
|
|
|
class _Pred = equal_to<remove_const_t<_Key>>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp>>,
|
[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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
_Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
|
|
|
|
-> unordered_map<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
-> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_map(_InputIterator, _InputIterator, _Allocator)
|
|
|
|
-> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Hash, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
-> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
_Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, 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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
-> unordered_map<remove_const_t<_Key>, _Tp,
|
|
|
|
hash<remove_const_t<_Key>>,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, 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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
|
|
|
|
-> unordered_map<remove_const_t<_Key>, _Tp,
|
|
|
|
hash<remove_const_t<_Key>>,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, 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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
-> unordered_map<remove_const_t<_Key>, _Tp, _Hash,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql,
|
|
|
|
const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
_InputIterator __first, _InputIterator __last)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
const unordered_map& __u)
|
|
|
|
: __table_(__u.__table_)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__u.bucket_count());
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
const unordered_map& __u, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__u.__table_, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__u.bucket_count());
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
unordered_map&& __u)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
|
2011-07-01 05:18:19 +08:00
|
|
|
: __table_(_VSTD::move(__u.__table_))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2013-07-31 05:04:42 +08:00
|
|
|
__get_db()->swap(this, &__u);
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
unordered_map&& __u, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__a != __u.get_allocator())
|
|
|
|
{
|
|
|
|
iterator __i = __u.begin();
|
2016-02-11 19:59:44 +08:00
|
|
|
while (__u.size() != 0) {
|
2018-06-05 04:38:23 +08:00
|
|
|
__table_.__emplace_unique(
|
|
|
|
__u.__table_.remove((__i++).__i_)->__value_.__move());
|
2016-02-11 19:59:44 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2013-07-31 05:04:42 +08:00
|
|
|
else
|
|
|
|
__get_db()->swap(this, &__u);
|
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
initializer_list<value_type> __il)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
__table_ = _VSTD::move(__u.__table_);
|
2010-05-12 03:42:16 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
|
|
|
|
initializer_list<value_type> __il)
|
|
|
|
{
|
|
|
|
__table_.__assign_unique(__il.begin(), __il.end());
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
|
|
|
|
_InputIterator __last)
|
|
|
|
{
|
|
|
|
for (; __first != __last; ++__first)
|
|
|
|
__table_.__insert_unique(*__first);
|
|
|
|
}
|
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-02-12 05:45:53 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
_Tp&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
|
|
|
|
{
|
|
|
|
return __table_.__emplace_unique_key_args(__k,
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
piecewise_construct, _VSTD::forward_as_tuple(__k),
|
|
|
|
_VSTD::forward_as_tuple()).first->__get_value().second;
|
2016-02-12 05:45:53 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
_Tp&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
|
|
|
|
{
|
2016-02-12 05:45:53 +08:00
|
|
|
return __table_.__emplace_unique_key_args(__k,
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)),
|
|
|
|
_VSTD::forward_as_tuple()).first->__get_value().second;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
2017-04-19 06:50:56 +08:00
|
|
|
#else // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
|
|
|
|
{
|
|
|
|
__node_allocator& __na = __table_.__node_alloc();
|
|
|
|
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
2018-06-05 04:38:23 +08:00
|
|
|
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
|
2017-04-19 06:50:56 +08:00
|
|
|
__h.get_deleter().__first_constructed = true;
|
2018-06-05 04:38:23 +08:00
|
|
|
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
|
2017-04-19 06:50:56 +08:00
|
|
|
__h.get_deleter().__second_constructed = true;
|
2020-07-30 21:42:23 +08:00
|
|
|
return __h;
|
2017-04-19 06:50:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
_Tp&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
|
|
|
|
{
|
|
|
|
iterator __i = find(__k);
|
|
|
|
if (__i != end())
|
|
|
|
return __i->second;
|
|
|
|
__node_holder __h = __construct_node_with_key(__k);
|
|
|
|
pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
|
|
|
|
__h.release();
|
|
|
|
return __r.first->second;
|
|
|
|
}
|
|
|
|
|
2021-04-19 10:15:38 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
_Tp&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
|
|
|
|
{
|
|
|
|
iterator __i = find(__k);
|
|
|
|
if (__i == end())
|
2019-02-13 00:06:02 +08:00
|
|
|
__throw_out_of_range("unordered_map::at: key not found");
|
2010-05-12 03:42:16 +08:00
|
|
|
return __i->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
const _Tp&
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
|
|
|
|
{
|
|
|
|
const_iterator __i = find(__k);
|
|
|
|
if (__i == end())
|
2019-02-13 00:06:02 +08:00
|
|
|
__throw_out_of_range("unordered_map::at: key not found");
|
2010-05-12 03:42:16 +08:00
|
|
|
return __i->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2010-09-24 02:58:28 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2020-05-02 19:58:03 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
|
|
|
|
class _Predicate>
|
2018-12-15 02:49:35 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2020-05-02 19:58:03 +08:00
|
|
|
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
|
|
|
|
erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
|
|
|
|
_Predicate __pred) {
|
2021-03-22 04:53:09 +08:00
|
|
|
return _VSTD::__libcpp_erase_if_container(__c, __pred);
|
2020-05-02 19:58:03 +08:00
|
|
|
}
|
2018-12-15 02:49:35 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
bool
|
|
|
|
operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
|
|
|
{
|
|
|
|
if (__x.size() != __y.size())
|
|
|
|
return false;
|
|
|
|
typedef typename unordered_map<_Key, _Tp, _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->first);
|
|
|
|
if (__j == __ey || !(*__i == *__j))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2010-09-24 02:58:28 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
|
|
|
{
|
|
|
|
return !(__x == __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
|
|
|
|
class _Alloc = allocator<pair<const _Key, _Tp> > >
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS unordered_multimap
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
2021-03-04 00:10:49 +08:00
|
|
|
typedef __identity_t<_Hash> hasher;
|
|
|
|
typedef __identity_t<_Pred> key_equal;
|
|
|
|
typedef __identity_t<_Alloc> allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
|
|
|
typedef value_type& reference;
|
|
|
|
typedef const value_type& const_reference;
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
static_assert((is_same<value_type, typename allocator_type::value_type>::value),
|
|
|
|
"Invalid allocator::value_type");
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
private:
|
2020-11-10 20:49:55 +08:00
|
|
|
typedef __hash_value_type<key_type, mapped_type> __value_type;
|
|
|
|
typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
|
|
|
|
typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher> __key_equal;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
|
2020-11-10 20:49:55 +08:00
|
|
|
__value_type>::type __allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
typedef __hash_table<__value_type, __hasher,
|
|
|
|
__key_equal, __allocator_type> __table;
|
|
|
|
|
|
|
|
__table __table_;
|
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
typedef typename __table::_NodeTypes _NodeTypes;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename __table::__node_traits __node_traits;
|
|
|
|
typedef typename __table::__node_allocator __node_allocator;
|
|
|
|
typedef typename __table::__node __node;
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __hash_map_node_destructor<__node_allocator> _Dp;
|
|
|
|
typedef unique_ptr<__node, _Dp> __node_holder;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
2016-02-11 04:46:23 +08:00
|
|
|
static_assert((is_same<typename __node_traits::size_type,
|
|
|
|
typename __alloc_traits::size_type>::value),
|
|
|
|
"Allocator uses different size_type for different types");
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
|
|
typedef typename __alloc_traits::const_pointer const_pointer;
|
2016-02-11 04:46:23 +08:00
|
|
|
typedef typename __table::size_type size_type;
|
|
|
|
typedef typename __table::difference_type difference_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
typedef __hash_map_iterator<typename __table::iterator> iterator;
|
|
|
|
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
|
|
|
|
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
|
|
|
|
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
|
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
typedef __map_node_handle<__node, allocator_type> node_type;
|
|
|
|
#endif
|
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS unordered_map;
|
|
|
|
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
|
2022-01-11 07:33:35 +08:00
|
|
|
{
|
|
|
|
_VSTD::__debug_db_insert_c(this);
|
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(),
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
unordered_multimap(size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap(_InputIterator __first, _InputIterator __last);
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap(_InputIterator __first, _InputIterator __last,
|
|
|
|
size_type __n, const hasher& __hf = hasher(),
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap(_InputIterator __first, _InputIterator __last,
|
|
|
|
size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit unordered_multimap(const allocator_type& __a);
|
|
|
|
unordered_multimap(const unordered_multimap& __u);
|
|
|
|
unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap(unordered_multimap&& __u)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
|
|
|
|
unordered_multimap(initializer_list<value_type> __il);
|
|
|
|
unordered_multimap(initializer_list<value_type> __il, size_type __n,
|
|
|
|
const hasher& __hf = hasher(),
|
|
|
|
const key_equal& __eql = key_equal());
|
|
|
|
unordered_multimap(initializer_list<value_type> __il, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql,
|
|
|
|
const allocator_type& __a);
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2013-09-12 11:00:31 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_multimap(size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_multimap(__n, hasher(), key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
|
|
|
|
: unordered_multimap(__n, __hf, key_equal(), __a) {}
|
|
|
|
template <class _InputIterator>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) {}
|
|
|
|
template <class _InputIterator>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& __a)
|
|
|
|
: unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
|
|
|
|
: unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-05-30 00:01:36 +08:00
|
|
|
unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
2013-09-12 11:00:31 +08:00
|
|
|
const allocator_type& __a)
|
|
|
|
: unordered_multimap(__il, __n, __hf, key_equal(), __a) {}
|
|
|
|
#endif
|
[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-12 00:14:56 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
~unordered_multimap() {
|
|
|
|
static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
|
|
|
|
}
|
|
|
|
|
2011-07-02 03:24:36 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
unordered_multimap& operator=(const unordered_multimap& __u)
|
|
|
|
{
|
2016-07-18 21:19:00 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2011-07-02 03:24:36 +08:00
|
|
|
__table_ = __u.__table_;
|
2013-06-22 23:21:29 +08:00
|
|
|
#else
|
2021-09-29 01:15:18 +08:00
|
|
|
if (this != _VSTD::addressof(__u)) {
|
2014-02-08 12:03:14 +08:00
|
|
|
__table_.clear();
|
|
|
|
__table_.hash_function() = __u.__table_.hash_function();
|
|
|
|
__table_.key_eq() = __u.__table_.key_eq();
|
|
|
|
__table_.max_load_factor() = __u.__table_.max_load_factor();
|
|
|
|
__table_.__copy_assign_alloc(__u.__table_);
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
2013-06-22 23:21:29 +08:00
|
|
|
#endif
|
2011-07-02 03:24:36 +08:00
|
|
|
return *this;
|
|
|
|
}
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
unordered_multimap& operator=(unordered_multimap&& __u)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap& operator=(initializer_list<value_type> __il);
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
allocator_type get_allocator() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{return allocator_type(__table_.__node_alloc());}
|
|
|
|
|
2017-11-15 13:51:26 +08:00
|
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
bool empty() const _NOEXCEPT {return __table_.size() == 0;}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type size() const _NOEXCEPT {return __table_.size();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type max_size() const _NOEXCEPT {return __table_.max_size();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
iterator begin() _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
iterator end() _NOEXCEPT {return __table_.end();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator begin() const _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator end() const _NOEXCEPT {return __table_.end();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
const_iterator cend() const _NOEXCEPT {return __table_.end();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-04-18 09:40:45 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __p, const value_type& __x)
|
|
|
|
{return __table_.__insert_multi(__p.__i_, __x);}
|
|
|
|
|
|
|
|
template <class _InputIterator>
|
2016-04-22 09:04:55 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-04-18 09:40:45 +08:00
|
|
|
void insert(_InputIterator __first, _InputIterator __last);
|
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-04-18 09:40:45 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void insert(initializer_list<value_type> __il)
|
|
|
|
{insert(__il.begin(), __il.end());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __p, value_type&& __x)
|
|
|
|
{return __table_.__insert_multi(__p.__i_, _VSTD::move(__x));}
|
|
|
|
|
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(_Pp&& __x)
|
|
|
|
{return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));}
|
|
|
|
|
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __p, _Pp&& __x)
|
|
|
|
{return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));}
|
|
|
|
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class... _Args>
|
2016-02-11 19:59:44 +08:00
|
|
|
iterator emplace(_Args&&... __args) {
|
|
|
|
return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class... _Args>
|
2016-02-11 19:59:44 +08:00
|
|
|
iterator emplace_hint(const_iterator __p, _Args&&... __args) {
|
|
|
|
return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2016-02-11 19:59:44 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator __p) {return __table_.erase(__p.__i_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __first, const_iterator __last)
|
|
|
|
{return __table_.erase(__first.__i_, __last.__i_);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
void clear() _NOEXCEPT {__table_.clear();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to unordered_multimap::insert()");
|
|
|
|
return __table_.template __node_handle_insert_multi<node_type>(
|
|
|
|
_VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __hint, node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to unordered_multimap::insert()");
|
|
|
|
return __table_.template __node_handle_insert_multi<node_type>(
|
|
|
|
__hint.__i_, _VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(key_type const& __key)
|
|
|
|
{
|
|
|
|
return __table_.template __node_handle_extract<node_type>(__key);
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(const_iterator __it)
|
|
|
|
{
|
|
|
|
return __table_.template __node_handle_extract<node_type>(
|
|
|
|
__it.__i_);
|
|
|
|
}
|
2018-11-01 01:31:35 +08:00
|
|
|
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
}
|
|
|
|
template <class _H2, class _P2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __table_.__node_handle_merge_multi(__source.__table_);
|
|
|
|
}
|
2018-08-01 09:33:38 +08:00
|
|
|
#endif
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
void swap(unordered_multimap& __u)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<__table>::value)
|
|
|
|
{__table_.swap(__u.__table_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
hasher hash_function() const
|
|
|
|
{return __table_.hash_function().hash_function();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
key_equal key_eq() const
|
|
|
|
{return __table_.key_eq().key_eq();}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator find(const key_type& __k) {return __table_.find(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator find(const _K2& __k) {return __table_.find(__k);}
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const_iterator find(const _K2& __k) const {return __table_.find(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
size_type count(const _K2& __k) const {return __table_.__count_multi(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const key_type& __k) const {return find(__k) != end();}
|
|
|
|
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const _K2& __k) const {return find(__k) != end();}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
2020-11-10 20:49:55 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator, iterator> equal_range(const key_type& __k)
|
|
|
|
{return __table_.__equal_range_multi(__k);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
|
|
|
|
{return __table_.__equal_range_multi(__k);}
|
2021-09-01 01:04:29 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, iterator> equal_range(const _K2& __k)
|
|
|
|
{return __table_.__equal_range_multi(__k);}
|
|
|
|
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
|
|
|
|
{return __table_.__equal_range_multi(__k);}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
size_type max_bucket_count() const _NOEXCEPT
|
|
|
|
{return __table_.max_bucket_count();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type bucket_size(size_type __n) const
|
|
|
|
{return __table_.bucket_size(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
local_iterator begin(size_type __n) {return __table_.begin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
local_iterator end(size_type __n) {return __table_.end(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
|
|
|
|
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
float load_factor() const _NOEXCEPT {return __table_.load_factor();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-05 02:54:24 +08:00
|
|
|
float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void rehash(size_type __n) {__table_.rehash(__n);}
|
2010-09-24 02:58:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void reserve(size_type __n) {__table_.reserve(__n);}
|
|
|
|
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
|
|
|
bool __dereferenceable(const const_iterator* __i) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __decrementable(const const_iterator* __i) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __addable(const const_iterator* __i, ptrdiff_t __n) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
|
2021-10-10 21:18:46 +08:00
|
|
|
{return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_DEBUG_LEVEL == 2
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
|
2016-02-11 19:59:44 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2021-08-17 23:59:07 +08:00
|
|
|
#if _LIBCPP_STD_VER >= 17
|
2019-07-16 04:06:01 +08:00
|
|
|
template<class _InputIterator,
|
|
|
|
class _Hash = hash<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Pred = equal_to<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
_Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
|
|
|
|
-> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
|
|
|
|
class _Pred = equal_to<remove_const_t<_Key>>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp>>,
|
[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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
|
|
|
|
_Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
|
|
|
|
-> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
-> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_multimap(_InputIterator, _InputIterator, _Allocator)
|
|
|
|
-> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Hash, class _Allocator,
|
2021-11-10 01:21:02 +08:00
|
|
|
class = enable_if_t<__is_cpp17_input_iterator<_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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
-> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
_Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, 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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
|
|
|
|
-> unordered_multimap<remove_const_t<_Key>, _Tp,
|
|
|
|
hash<remove_const_t<_Key>>,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, 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-18 00:26:09 +08:00
|
|
|
class = enable_if_t<__is_allocator<_Allocator>::value>>
|
2019-07-16 04:06:01 +08:00
|
|
|
unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
|
|
|
|
-> unordered_multimap<remove_const_t<_Key>, _Tp,
|
|
|
|
hash<remove_const_t<_Key>>,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, 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-18 00:26:09 +08: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-16 04:06:01 +08:00
|
|
|
unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
|
|
|
|
-> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash,
|
|
|
|
equal_to<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
size_type __n, const hasher& __hf, const key_equal& __eql,
|
|
|
|
const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
_InputIterator __first, _InputIterator __last)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
_InputIterator __first, _InputIterator __last, size_type __n,
|
|
|
|
const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__first, __last);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
const unordered_multimap& __u)
|
|
|
|
: __table_(__u.__table_)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__u.bucket_count());
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
const unordered_multimap& __u, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__u.__table_, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__u.bucket_count());
|
|
|
|
insert(__u.begin(), __u.end());
|
|
|
|
}
|
|
|
|
|
2017-04-19 06:50:56 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
unordered_multimap&& __u)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
|
2011-07-01 05:18:19 +08:00
|
|
|
: __table_(_VSTD::move(__u.__table_))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2013-07-31 05:04:42 +08:00
|
|
|
__get_db()->swap(this, &__u);
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
unordered_multimap&& __u, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__a != __u.get_allocator())
|
|
|
|
{
|
|
|
|
iterator __i = __u.begin();
|
|
|
|
while (__u.size() != 0)
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
{
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.__insert_multi(
|
2018-06-05 04:38:23 +08:00
|
|
|
__u.__table_.remove((__i++).__i_)->__value_.__move());
|
Debug mode for unordered_set. I believe this to be fairly complete for
unordered_set, however it is not complete yet for unordered_multiset,
unordered_map or unordered_multimap. There has been a lot of work done
for these other three containers, however that work was done just to
keep all of the tests passing.
You can try this out with -D_LIBCPP_DEBUG2. You will have to link to a
libc++.dylib that has been compiled with src/debug.cpp. So far, vector
(but not vector<bool>), list, and unordered_set are treated. I hope to
get the other three unordered containers up fairly quickly now that
unordered_set is done.
The flag _LIBCPP_DEBUG2 will eventually be changed to _LIBCPP_DEBUG, but
not today. This is my second effort at getting debug mode going for
libc++, and I'm not quite yet ready to throw all of the work under the
first attempt away.
The basic design is that all of the debug information is kept in a
central database, instead of in the containers. This has been done as
an attempt to have debug mode and non-debug mode be ABI compatible with
each other. There are some circumstances where if you construct a
container in an environment without debug mode and pass it into debug
mode, the checking will get confused and let you know with a readable
error message. Passing containers the other way: from debug mode out to
a non-debugging mode container should be 100% safe (at least that is the
goal).
llvm-svn: 186991
2013-07-24 06:01:58 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
2020-10-03 03:02:52 +08:00
|
|
|
#if _LIBCPP_DEBUG_LEVEL == 2
|
2013-07-31 05:04:42 +08:00
|
|
|
else
|
|
|
|
__get_db()->swap(this, &__u);
|
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
initializer_list<value_type> __il)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql)
|
|
|
|
: __table_(__hf, __eql)
|
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|
|
|
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
|
|
|
|
const key_equal& __eql, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __table_(__hf, __eql, typename __table::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2022-01-11 07:33:35 +08:00
|
|
|
_VSTD::__debug_db_insert_c(this);
|
2010-05-12 03:42:16 +08:00
|
|
|
__table_.rehash(__n);
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
__table_ = _VSTD::move(__u.__table_);
|
2010-05-12 03:42:16 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
|
|
|
|
initializer_list<value_type> __il)
|
|
|
|
{
|
|
|
|
__table_.__assign_multi(__il.begin(), __il.end());
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2011-08-13 05:56:02 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
template <class _InputIterator>
|
2016-04-22 09:04:55 +08:00
|
|
|
inline
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
|
|
|
|
_InputIterator __last)
|
|
|
|
{
|
|
|
|
for (; __first != __last; ++__first)
|
|
|
|
__table_.__insert_multi(*__first);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2010-09-24 02:58:28 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
2011-06-05 02:54:24 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2020-05-02 19:58:03 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
|
|
|
|
class _Predicate>
|
2018-12-15 02:49:35 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2020-05-02 19:58:03 +08:00
|
|
|
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
|
|
|
|
erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
|
|
|
|
_Predicate __pred) {
|
2021-03-22 04:53:09 +08:00
|
|
|
return _VSTD::__libcpp_erase_if_container(__c, __pred);
|
2020-05-02 19:58:03 +08:00
|
|
|
}
|
2018-12-15 02:49:35 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
|
|
|
bool
|
|
|
|
operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
|
|
|
{
|
|
|
|
if (__x.size() != __y.size())
|
|
|
|
return false;
|
|
|
|
typedef typename unordered_multimap<_Key, _Tp, _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->first);
|
|
|
|
_EqRng __yeq = __y.equal_range(__i->first);
|
2011-07-01 05:18:19 +08:00
|
|
|
if (_VSTD::distance(__xeq.first, __xeq.second) !=
|
|
|
|
_VSTD::distance(__yeq.first, __yeq.second) ||
|
|
|
|
!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
|
2010-05-12 03:42:16 +08:00
|
|
|
return false;
|
|
|
|
__i = __xeq.second;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
2010-09-24 02:58:28 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
|
|
|
|
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
|
|
|
|
{
|
|
|
|
return !(__x == __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
2021-04-21 00:03:32 +08:00
|
|
|
#endif // _LIBCPP_UNORDERED_MAP
|