// -*- C++ -*- //===----------------------------------------------------------------------===// // // 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 // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_UNORDERED_MAP #define _LIBCPP_UNORDERED_MAP /* unordered_map synopsis #include namespace std { template , class Pred = equal_to, class Alloc = allocator>> 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 value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef typename allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer; typedef typename allocator_traits::size_type size_type; typedef typename allocator_traits::difference_type difference_type; typedef /unspecified/ iterator; typedef /unspecified/ const_iterator; typedef /unspecified/ local_iterator; typedef /unspecified/ const_local_iterator; typedef unspecified node_type; // C++17 typedef INSERT_RETURN_TYPE insert_return_type; // C++17 unordered_map() noexcept( is_nothrow_default_constructible::value && is_nothrow_default_constructible::value && is_nothrow_default_constructible::value); explicit unordered_map(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template 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()); template R> unordered_map(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); // C++23 explicit unordered_map(const allocator_type&); unordered_map(const unordered_map&); unordered_map(const unordered_map&, const Allocator&); unordered_map(unordered_map&&) noexcept( is_nothrow_move_constructible::value && is_nothrow_move_constructible::value && is_nothrow_move_constructible::value); unordered_map(unordered_map&&, const Allocator&); unordered_map(initializer_list, size_type n = 0, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); 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 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 unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_map(f, l, n, hf, key_equal(), a) {} // C++14 template R> unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_map(from_range, std::forward(rg), n, hasher(), key_equal(), a) { } // C++23 template R> unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a) : unordered_map(from_range, std::forward(rg), n, hf, key_equal(), a) { } // C++23 unordered_map(initializer_list il, size_type n, const allocator_type& a) : unordered_map(il, n, hasher(), key_equal(), a) {} // C++14 unordered_map(initializer_list il, size_type n, const hasher& hf, const allocator_type& a) : unordered_map(il, n, hf, key_equal(), a) {} // C++14 ~unordered_map(); unordered_map& operator=(const unordered_map&); unordered_map& operator=(unordered_map&&) noexcept( allocator_type::propagate_on_container_move_assignment::value && is_nothrow_move_assignable::value && is_nothrow_move_assignable::value && is_nothrow_move_assignable::value); unordered_map& operator=(initializer_list); allocator_type get_allocator() const noexcept; bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; 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; template pair emplace(Args&&... args); template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& obj); template pair insert(P&& obj); iterator insert(const_iterator hint, const value_type& obj); template iterator insert(const_iterator hint, P&& obj); template void insert(InputIterator first, InputIterator last); template R> void insert_range(R&& rg); // C++23 void insert(initializer_list); 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 template pair try_emplace(const key_type& k, Args&&... args); // C++17 template pair try_emplace(key_type&& k, Args&&... args); // C++17 template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17 template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17 template pair insert_or_assign(const key_type& k, M&& obj); // C++17 template pair insert_or_assign(key_type&& k, M&& obj); // C++17 template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17 template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17 iterator erase(const_iterator position); iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; template void merge(unordered_map& source); // C++17 template void merge(unordered_map&& source); // C++17 template void merge(unordered_multimap& source); // C++17 template void merge(unordered_multimap&& source); // C++17 void swap(unordered_map&) noexcept( (!allocator_type::propagate_on_container_swap::value || __is_nothrow_swappable::value) && __is_nothrow_swappable::value && __is_nothrow_swappable::value); hasher hash_function() const; key_equal key_eq() const; iterator find(const key_type& k); const_iterator find(const key_type& k) const; template iterator find(const K& x); // C++20 template const_iterator find(const K& x) const; // C++20 size_type count(const key_type& k) const; template size_type count(const K& k) const; // C++20 bool contains(const key_type& k) const; // C++20 template bool contains(const K& k) const; // C++20 pair equal_range(const key_type& k); pair equal_range(const key_type& k) const; template pair equal_range(const K& k); // C++20 template pair equal_range(const K& k) const; // C++20 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; size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; 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; float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n); }; template>, class Pred = equal_to>, class Allocator = allocator>> unordered_map(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map, iter_value_t, Hash, Pred, Allocator>; // C++17 template>, class Pred = equal_to>, class Allocator = allocator>> unordered_map(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map, range-mapped-type, Hash, Pred, Allocator>; // C++23 template, class Pred = equal_to, class Allocator = allocator>> unordered_map(initializer_list>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map; // C++17 template unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_map, iter_val_t, hash>, equal_to>, Allocator>; // C++17 template unordered_map(InputIterator, InputIterator, Allocator) -> unordered_map, iter_val_t, hash>, equal_to>, Allocator>; // C++17 template unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_map, iter_val_t, Hash, equal_to>, Allocator>; // C++17 template unordered_map(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_map, range-mapped-type, hash>, equal_to>, Allocator>; // C++23 template unordered_map(from_range_t, R&&, Allocator) -> unordered_map, range-mapped-type, hash>, equal_to>, Allocator>; // C++23 template unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_map, range-mapped-type, Hash, equal_to>, Allocator>; // C++23 template unordered_map(initializer_list>, typename see below::size_type, Allocator) -> unordered_map, equal_to, Allocator>; // C++17 template unordered_map(initializer_list>, Allocator) -> unordered_map, equal_to, Allocator>; // C++17 template unordered_map(initializer_list>, typename see below::size_type, Hash, Allocator) -> unordered_map, Allocator>; // C++17 template void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); template bool operator==(const unordered_map& x, const unordered_map& y); template bool operator!=(const unordered_map& x, const unordered_map& y); // Removed in C++20 template , class Pred = equal_to, class Alloc = allocator>> 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 value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef typename allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer; typedef typename allocator_traits::size_type size_type; typedef typename allocator_traits::difference_type difference_type; typedef /unspecified/ iterator; typedef /unspecified/ const_iterator; typedef /unspecified/ local_iterator; typedef /unspecified/ const_local_iterator; typedef unspecified node_type; // C++17 unordered_multimap() noexcept( is_nothrow_default_constructible::value && is_nothrow_default_constructible::value && is_nothrow_default_constructible::value); explicit unordered_multimap(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template 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()); template R> unordered_multimap(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); // C++23 explicit unordered_multimap(const allocator_type&); unordered_multimap(const unordered_multimap&); unordered_multimap(const unordered_multimap&, const Allocator&); unordered_multimap(unordered_multimap&&) noexcept( is_nothrow_move_constructible::value && is_nothrow_move_constructible::value && is_nothrow_move_constructible::value); unordered_multimap(unordered_multimap&&, const Allocator&); unordered_multimap(initializer_list, size_type n = 0, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); 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 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 unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(f, l, n, hf, key_equal(), a) {} // C++14 template R> unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_multimap(from_range, std::forward(rg), n, hasher(), key_equal(), a) { } // C++23 template R> unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(from_range, std::forward(rg), n, hf, key_equal(), a) { } // C++23 unordered_multimap(initializer_list il, size_type n, const allocator_type& a) : unordered_multimap(il, n, hasher(), key_equal(), a) {} // C++14 unordered_multimap(initializer_list il, size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(il, n, hf, key_equal(), a) {} // C++14 ~unordered_multimap(); unordered_multimap& operator=(const unordered_multimap&); unordered_multimap& operator=(unordered_multimap&&) noexcept( allocator_type::propagate_on_container_move_assignment::value && is_nothrow_move_assignable::value && is_nothrow_move_assignable::value && is_nothrow_move_assignable::value); unordered_multimap& operator=(initializer_list); allocator_type get_allocator() const noexcept; bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; 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; template iterator emplace(Args&&... args); template iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj); template iterator insert(P&& obj); iterator insert(const_iterator hint, const value_type& obj); template iterator insert(const_iterator hint, P&& obj); template void insert(InputIterator first, InputIterator last); template R> void insert_range(R&& rg); // C++23 void insert(initializer_list); 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 iterator erase(const_iterator position); iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; template void merge(unordered_multimap& source); // C++17 template void merge(unordered_multimap&& source); // C++17 template void merge(unordered_map& source); // C++17 template void merge(unordered_map&& source); // C++17 void swap(unordered_multimap&) noexcept( (!allocator_type::propagate_on_container_swap::value || __is_nothrow_swappable::value) && __is_nothrow_swappable::value && __is_nothrow_swappable::value); hasher hash_function() const; key_equal key_eq() const; iterator find(const key_type& k); const_iterator find(const key_type& k) const; template iterator find(const K& x); // C++20 template const_iterator find(const K& x) const; // C++20 size_type count(const key_type& k) const; template size_type count(const K& k) const; // C++20 bool contains(const key_type& k) const; // C++20 template bool contains(const K& k) const; // C++20 pair equal_range(const key_type& k); pair equal_range(const key_type& k) const; template pair equal_range(const K& k); // C++20 template pair equal_range(const K& k) const; // C++20 size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; 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; float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n); }; template>, class Pred = equal_to>, class Allocator = allocator>> unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap, iter_value_t, Hash, Pred, Allocator>; // C++17 template>, class Pred = equal_to>, class Allocator = allocator>> unordered_multimap(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap, range-mapped-type, Hash, Pred, Allocator>; // C++23 template, class Pred = equal_to, class Allocator = allocator>> unordered_multimap(initializer_list>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap; // C++17 template unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_multimap, iter_val_t, hash>, equal_to>, Allocator>; // C++17 template unordered_multimap(InputIterator, InputIterator, Allocator) -> unordered_multimap, iter_val_t, hash>, equal_to>, Allocator>; // C++17 template unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_multimap, iter_val_t, Hash, equal_to>, Allocator>; // C++17 template unordered_multimap(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_multimap, range-mapped-type, hash>, equal_to>, Allocator>; // C++23 template unordered_multimap(from_range_t, R&&, Allocator) -> unordered_multimap, range-mapped-type, hash>, equal_to>, Allocator>; // C++23 template unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_multimap, range-mapped-type, Hash, equal_to>, Allocator>; // C++23 template unordered_multimap(initializer_list>, typename see below::size_type, Allocator) -> unordered_multimap, equal_to, Allocator>; // C++17 template unordered_multimap(initializer_list>, Allocator) -> unordered_multimap, equal_to, Allocator>; // C++17 template unordered_multimap(initializer_list>, typename see below::size_type, Hash, Allocator) -> unordered_multimap, Allocator>; // C++17 template void swap(unordered_multimap& x, unordered_multimap& y) noexcept(noexcept(x.swap(y))); template typename unordered_map::size_type erase_if(unordered_map& c, Predicate pred); // C++20 template typename unordered_multimap::size_type erase_if(unordered_multimap& c, Predicate pred); // C++20 template bool operator==(const unordered_multimap& x, const unordered_multimap& y); template bool operator!=(const unordered_multimap& x, const unordered_multimap& y); // Removed in C++20 } // std */ #include <__algorithm/is_permutation.h> #include <__assert> // all public C++ headers provide the assertion handler #include <__availability> #include <__config> #include <__functional/is_transparent.h> #include <__functional/operations.h> #include <__hash_table> #include <__iterator/distance.h> #include <__iterator/erase_if_container.h> #include <__iterator/iterator_traits.h> #include <__iterator/ranges_iterator_traits.h> #include <__memory/addressof.h> #include <__memory/allocator.h> #include <__memory_resource/polymorphic_allocator.h> #include <__node_handle> #include <__ranges/concepts.h> #include <__ranges/container_compatible_range.h> #include <__ranges/from_range.h> #include <__type_traits/is_allocator.h> #include <__type_traits/type_identity.h> #include <__utility/forward.h> #include #include #include // standard-mandated includes // [iterator.range] #include <__iterator/access.h> #include <__iterator/data.h> #include <__iterator/empty.h> #include <__iterator/reverse_access.h> #include <__iterator/size.h> // [unord.map.syn] #include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD template ::value && !__libcpp_is_final<_Hash>::value> class __unordered_map_hasher : private _Hash { public: _LIBCPP_INLINE_VISIBILITY __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) : _Hash() {} _LIBCPP_INLINE_VISIBILITY __unordered_map_hasher(const _Hash& __h) _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value) : _Hash(__h) {} _LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const _NOEXCEPT {return *this;} _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Cp& __x) const {return static_cast(*this)(__x.__get_value().first);} _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Key& __x) const {return static_cast(*this)(__x);} #if _LIBCPP_STD_VER >= 20 template _LIBCPP_INLINE_VISIBILITY size_t operator()(const _K2& __x) const {return static_cast(*this)(__x);} #endif _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_hasher& __y) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) { using _VSTD::swap; swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y)); } }; template class __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, false> { _Hash __hash_; public: _LIBCPP_INLINE_VISIBILITY __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) : __hash_() {} _LIBCPP_INLINE_VISIBILITY __unordered_map_hasher(const _Hash& __h) _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value) : __hash_(__h) {} _LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const _NOEXCEPT {return __hash_;} _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Cp& __x) const {return __hash_(__x.__get_value().first);} _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Key& __x) const {return __hash_(__x);} #if _LIBCPP_STD_VER >= 20 template _LIBCPP_INLINE_VISIBILITY size_t operator()(const _K2& __x) const {return __hash_(__x);} #endif _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_hasher& __y) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) { using _VSTD::swap; swap(__hash_, __y.__hash_); } }; template inline _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __x, __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) { __x.swap(__y); } template ::value && !__libcpp_is_final<_Pred>::value> class __unordered_map_equal : private _Pred { public: _LIBCPP_INLINE_VISIBILITY __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) : _Pred() {} _LIBCPP_INLINE_VISIBILITY __unordered_map_equal(const _Pred& __p) _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value) : _Pred(__p) {} _LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const _NOEXCEPT {return *this;} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _Cp& __y) const {return static_cast(*this)(__x.__get_value().first, __y.__get_value().first);} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _Key& __y) const {return static_cast(*this)(__x.__get_value().first, __y);} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _Cp& __y) const {return static_cast(*this)(__x, __y.__get_value().first);} #if _LIBCPP_STD_VER >= 20 template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _K2& __y) const {return static_cast(*this)(__x.__get_value().first, __y);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _K2& __x, const _Cp& __y) const {return static_cast(*this)(__x, __y.__get_value().first);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _K2& __y) const {return static_cast(*this)(__x, __y);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _K2& __x, const _Key& __y) const {return static_cast(*this)(__x, __y);} #endif _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_equal& __y) _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) { using _VSTD::swap; swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y)); } }; template class __unordered_map_equal<_Key, _Cp, _Pred, _Hash, false> { _Pred __pred_; public: _LIBCPP_INLINE_VISIBILITY __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) : __pred_() {} _LIBCPP_INLINE_VISIBILITY __unordered_map_equal(const _Pred& __p) _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value) : __pred_(__p) {} _LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const _NOEXCEPT {return __pred_;} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _Cp& __y) const {return __pred_(__x.__get_value().first, __y.__get_value().first);} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _Key& __y) const {return __pred_(__x.__get_value().first, __y);} _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _Cp& __y) const {return __pred_(__x, __y.__get_value().first);} #if _LIBCPP_STD_VER >= 20 template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Cp& __x, const _K2& __y) const {return __pred_(__x.__get_value().first, __y);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _K2& __x, const _Cp& __y) const {return __pred_(__x, __y.__get_value().first);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _K2& __y) const {return __pred_(__x, __y);} template _LIBCPP_INLINE_VISIBILITY bool operator()(const _K2& __x, const _Key& __y) const {return __pred_(__x, __y);} #endif _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_equal& __y) _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) { using _VSTD::swap; swap(__pred_, __y.__pred_); } }; template inline _LIBCPP_INLINE_VISIBILITY void swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __x, __unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) { __x.swap(__y); } template class __hash_map_node_destructor { typedef _Alloc allocator_type; typedef allocator_traits __alloc_traits; public: typedef typename __alloc_traits::pointer pointer; private: allocator_type& __na_; __hash_map_node_destructor& operator=(const __hash_map_node_destructor&); public: bool __first_constructed; bool __second_constructed; _LIBCPP_INLINE_VISIBILITY explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT : __na_(__na), __first_constructed(false), __second_constructed(false) {} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __hash_map_node_destructor(__hash_node_destructor&& __x) _NOEXCEPT : __na_(__x.__na_), __first_constructed(__x.__value_constructed), __second_constructed(__x.__value_constructed) { __x.__value_constructed = false; } #else // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __hash_map_node_destructor(const __hash_node_destructor& __x) : __na_(__x.__na_), __first_constructed(__x.__value_constructed), __second_constructed(__x.__value_constructed) { const_cast(__x.__value_constructed) = false; } #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY void operator()(pointer __p) _NOEXCEPT { if (__second_constructed) __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().__get_value().second)); if (__first_constructed) __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__get_value().__get_value().first)); if (__p) __alloc_traits::deallocate(__na_, __p, 1); } }; #ifndef _LIBCPP_CXX03_LANG template struct _LIBCPP_STANDALONE_DEBUG __hash_value_type { typedef _Key key_type; typedef _Tp mapped_type; typedef pair value_type; typedef pair __nc_ref_pair_type; typedef pair __nc_rref_pair_type; private: value_type __cc_; public: _LIBCPP_INLINE_VISIBILITY value_type& __get_value() { #if _LIBCPP_STD_VER >= 17 return *_VSTD::launder(_VSTD::addressof(__cc_)); #else return __cc_; #endif } _LIBCPP_INLINE_VISIBILITY const value_type& __get_value() const { #if _LIBCPP_STD_VER >= 17 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(__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(__v.first)), _VSTD::move(__v.second)); } _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(const __hash_value_type& __v) { __ref() = __v.__get_value(); return *this; } _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(__hash_value_type&& __v) { __ref() = __v.__move(); return *this; } template ::value> > _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(_ValueTp&& __v) { __ref() = _VSTD::forward<_ValueTp>(__v); return *this; } private: __hash_value_type(const __hash_value_type& __v) = delete; __hash_value_type(__hash_value_type&& __v) = delete; template explicit __hash_value_type(_Args&& ...__args) = delete; ~__hash_value_type() = delete; }; #else template struct __hash_value_type { typedef _Key key_type; typedef _Tp mapped_type; typedef pair value_type; private: value_type __cc_; public: _LIBCPP_INLINE_VISIBILITY value_type& __get_value() { return __cc_; } _LIBCPP_INLINE_VISIBILITY const value_type& __get_value() const { return __cc_; } private: ~__hash_value_type(); }; #endif template class _LIBCPP_TEMPLATE_VIS __hash_map_iterator { _HashIterator __i_; typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; public: typedef forward_iterator_tag iterator_category; typedef typename _NodeTypes::__map_value_type value_type; typedef typename _NodeTypes::difference_type difference_type; typedef value_type& reference; typedef typename _NodeTypes::__map_value_type_pointer pointer; _LIBCPP_INLINE_VISIBILITY __hash_map_iterator() _NOEXCEPT {} _LIBCPP_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {} _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __i_->__get_value();} _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return pointer_traits::pointer_to(__i_->__get_value());} _LIBCPP_INLINE_VISIBILITY __hash_map_iterator& operator++() {++__i_; return *this;} _LIBCPP_INLINE_VISIBILITY __hash_map_iterator operator++(int) { __hash_map_iterator __t(*this); ++(*this); return __t; } friend _LIBCPP_INLINE_VISIBILITY bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {return __x.__i_ == __y.__i_;} #if _LIBCPP_STD_VER <= 17 friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {return __x.__i_ != __y.__i_;} #endif template friend class _LIBCPP_TEMPLATE_VIS unordered_map; template friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; template friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator; }; template class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator { _HashIterator __i_; typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; public: typedef forward_iterator_tag iterator_category; typedef typename _NodeTypes::__map_value_type value_type; typedef typename _NodeTypes::difference_type difference_type; typedef const value_type& reference; typedef typename _NodeTypes::__const_map_value_type_pointer pointer; _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator() _NOEXCEPT {} _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {} _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator( __hash_map_iterator __i) _NOEXCEPT : __i_(__i.__i_) {} _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __i_->__get_value();} _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return pointer_traits::pointer_to(__i_->__get_value());} _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator& operator++() {++__i_; return *this;} _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator operator++(int) { __hash_map_const_iterator __t(*this); ++(*this); return __t; } friend _LIBCPP_INLINE_VISIBILITY bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {return __x.__i_ == __y.__i_;} #if _LIBCPP_STD_VER <= 17 friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {return __x.__i_ != __y.__i_;} #endif template friend class _LIBCPP_TEMPLATE_VIS unordered_map; template friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; template friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator; template friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator; }; template class unordered_multimap; template , class _Pred = equal_to<_Key>, class _Alloc = allocator > > class _LIBCPP_TEMPLATE_VIS unordered_map { public: // types typedef _Key key_type; typedef _Tp mapped_type; typedef __type_identity_t<_Hash> hasher; typedef __type_identity_t<_Pred> key_equal; typedef __type_identity_t<_Alloc> allocator_type; typedef pair value_type; typedef value_type& reference; typedef const value_type& const_reference; static_assert((is_same::value), "Allocator::value_type must be same type as value_type"); private: typedef __hash_value_type __value_type; typedef __unordered_map_hasher __hasher; typedef __unordered_map_equal __key_equal; typedef __rebind_alloc, __value_type> __allocator_type; typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table; __table __table_; typedef typename __table::_NodeTypes _NodeTypes; 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; typedef __hash_map_node_destructor<__node_allocator> _Dp; typedef unique_ptr<__node, _Dp> __node_holder; typedef allocator_traits __alloc_traits; static_assert(is_same >::value, "[allocator.requirements] states that rebinding an allocator to the same type should result in the " "original allocator"); static_assert((is_same::value), ""); static_assert((is_same::value), ""); public: typedef typename __alloc_traits::pointer pointer; typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __table::size_type size_type; typedef typename __table::difference_type difference_type; typedef __hash_map_iterator iterator; typedef __hash_map_const_iterator const_iterator; typedef __hash_map_iterator local_iterator; typedef __hash_map_const_iterator const_local_iterator; #if _LIBCPP_STD_VER >= 17 typedef __map_node_handle<__node, allocator_type> node_type; typedef __insert_return_type insert_return_type; #endif template friend class _LIBCPP_TEMPLATE_VIS unordered_map; template friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; _LIBCPP_INLINE_VISIBILITY unordered_map() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) { } explicit _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a); template _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last); template _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); template _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a); #if _LIBCPP_STD_VER >= 23 template <_ContainerCompatibleRange _Range> _LIBCPP_HIDE_FROM_ABI unordered_map(from_range_t, _Range&& __range, size_type __n = /*implementation-defined*/0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : __table_(__hf, __eql, typename __table::allocator_type(__a)) { if (__n > 0) { __table_.__rehash_unique(__n); } insert_range(std::forward<_Range>(__range)); } #endif _LIBCPP_INLINE_VISIBILITY explicit unordered_map(const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u); _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u, const allocator_type& __a); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_map(unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list __il); _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list __il, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list __il, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a); #endif // _LIBCPP_CXX03_LANG #if _LIBCPP_STD_VER >= 14 _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 _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 _LIBCPP_INLINE_VISIBILITY unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__first, __last, __n, __hf, key_equal(), __a) {} #if _LIBCPP_STD_VER >= 23 template <_ContainerCompatibleRange _Range> _LIBCPP_HIDE_FROM_ABI unordered_map(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a) : unordered_map(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {} template <_ContainerCompatibleRange _Range> _LIBCPP_HIDE_FROM_ABI unordered_map(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {} #endif _LIBCPP_INLINE_VISIBILITY unordered_map(initializer_list __il, size_type __n, const allocator_type& __a) : unordered_map(__il, __n, hasher(), key_equal(), __a) {} _LIBCPP_INLINE_VISIBILITY unordered_map(initializer_list __il, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__il, __n, __hf, key_equal(), __a) {} #endif _LIBCPP_INLINE_VISIBILITY ~unordered_map() { static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), ""); } _LIBCPP_INLINE_VISIBILITY unordered_map& operator=(const unordered_map& __u) { #ifndef _LIBCPP_CXX03_LANG __table_ = __u.__table_; #else if (this != _VSTD::addressof(__u)) { __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()); } #endif return *this; } #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_map& operator=(unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); _LIBCPP_INLINE_VISIBILITY unordered_map& operator=(initializer_list __il); #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__table_.__node_alloc());} _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return __table_.size() == 0;} _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT {return __table_.size();} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return __table_.max_size();} _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator cend() const _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY pair insert(const value_type& __x) {return __table_.__insert_unique(__x);} _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; } template _LIBCPP_INLINE_VISIBILITY void insert(_InputIterator __first, _InputIterator __last); #if _LIBCPP_STD_VER >= 23 template <_ContainerCompatibleRange _Range> _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) { for (auto&& __element : __range) { __table_.__insert_unique(std::forward(__element)); } } #endif #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) {insert(__il.begin(), __il.end());} _LIBCPP_INLINE_VISIBILITY pair insert(value_type&& __x) {return __table_.__insert_unique(_VSTD::move(__x));} _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, value_type&& __x) { return __table_.__insert_unique(_VSTD::move(__x)).first; } template ::value> > _LIBCPP_INLINE_VISIBILITY pair insert(_Pp&& __x) {return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));} template ::value> > _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator, _Pp&& __x) { return insert(_VSTD::forward<_Pp>(__x)).first; } template _LIBCPP_INLINE_VISIBILITY pair emplace(_Args&&... __args) { return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator, _Args&&... __args) { return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; } #endif // _LIBCPP_CXX03_LANG #if _LIBCPP_STD_VER >= 17 template _LIBCPP_INLINE_VISIBILITY pair try_emplace(const key_type& __k, _Args&&... __args) { return __table_.__emplace_unique_key_args(__k, piecewise_construct, _VSTD::forward_as_tuple(__k), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); } template _LIBCPP_INLINE_VISIBILITY pair try_emplace(key_type&& __k, _Args&&... __args) { return __table_.__emplace_unique_key_args(__k, piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); } template _LIBCPP_INLINE_VISIBILITY iterator try_emplace(const_iterator, const key_type& __k, _Args&&... __args) { return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first; } template _LIBCPP_INLINE_VISIBILITY iterator try_emplace(const_iterator, key_type&& __k, _Args&&... __args) { return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first; } template _LIBCPP_INLINE_VISIBILITY pair insert_or_assign(const key_type& __k, _Vp&& __v) { pair __res = __table_.__emplace_unique_key_args(__k, __k, _VSTD::forward<_Vp>(__v)); if (!__res.second) { __res.first->second = _VSTD::forward<_Vp>(__v); } return __res; } template _LIBCPP_INLINE_VISIBILITY pair insert_or_assign(key_type&& __k, _Vp&& __v) { pair __res = __table_.__emplace_unique_key_args(__k, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)); if (!__res.second) { __res.first->second = _VSTD::forward<_Vp>(__v); } return __res; } template _LIBCPP_INLINE_VISIBILITY iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v) { return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first; } template _LIBCPP_INLINE_VISIBILITY iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v) { return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first; } #endif // _LIBCPP_STD_VER >= 17 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY iterator erase(iterator __p) {return __table_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __first, const_iterator __last) {return __table_.erase(__first.__i_, __last.__i_);} _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {__table_.clear();} #if _LIBCPP_STD_VER >= 17 _LIBCPP_INLINE_VISIBILITY insert_return_type insert(node_type&& __nh) { _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__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_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_map::insert()"); return __table_.template __node_handle_insert_unique( __hint.__i_, _VSTD::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) { return __table_.template __node_handle_extract(__key); } _LIBCPP_INLINE_VISIBILITY node_type extract(const_iterator __it) { return __table_.template __node_handle_extract( __it.__i_); } template _LIBCPP_INLINE_VISIBILITY void merge(unordered_map& __source) { _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__source.get_allocator() == get_allocator(), "merging container with incompatible allocator"); return __table_.__node_handle_merge_unique(__source.__table_); } template _LIBCPP_INLINE_VISIBILITY void merge(unordered_map&& __source) { _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__source.get_allocator() == get_allocator(), "merging container with incompatible allocator"); return __table_.__node_handle_merge_unique(__source.__table_); } template _LIBCPP_INLINE_VISIBILITY void merge(unordered_multimap& __source) { _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__source.get_allocator() == get_allocator(), "merging container with incompatible allocator"); return __table_.__node_handle_merge_unique(__source.__table_); } template _LIBCPP_INLINE_VISIBILITY void merge(unordered_multimap&& __source) { _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__source.get_allocator() == get_allocator(), "merging container with incompatible allocator"); return __table_.__node_handle_merge_unique(__source.__table_); } #endif _LIBCPP_INLINE_VISIBILITY void swap(unordered_map& __u) _NOEXCEPT_(__is_nothrow_swappable<__table>::value) { __table_.swap(__u.__table_);} _LIBCPP_INLINE_VISIBILITY hasher hash_function() const {return __table_.hash_function().hash_function();} _LIBCPP_INLINE_VISIBILITY key_equal key_eq() const {return __table_.key_eq().key_eq();} _LIBCPP_INLINE_VISIBILITY iterator find(const key_type& __k) {return __table_.find(__k);} _LIBCPP_INLINE_VISIBILITY const_iterator find(const key_type& __k) const {return __table_.find(__k);} #if _LIBCPP_STD_VER >= 20 template ::value && __is_transparent::value>* = nullptr> _LIBCPP_INLINE_VISIBILITY iterator find(const _K2& __k) {return __table_.find(__k);} template ::value && __is_transparent::value>* = nullptr> _LIBCPP_INLINE_VISIBILITY const_iterator find(const _K2& __k) const {return __table_.find(__k);} #endif // _LIBCPP_STD_VER >= 20 _LIBCPP_INLINE_VISIBILITY size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} #if _LIBCPP_STD_VER >= 20 template ::value && __is_transparent::value>* = nullptr> _LIBCPP_INLINE_VISIBILITY size_type count(const _K2& __k) const {return __table_.__count_unique(__k);} #endif // _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20 _LIBCPP_INLINE_VISIBILITY bool contains(const key_type& __k) const {return find(__k) != end();} template