Lines Matching refs:const
23 class Alloc = allocator<pair<const Key, T>>>
33 typedef pair<const key_type, mapped_type> value_type;
35 typedef const value_type& const_reference;
54 explicit unordered_map(size_type n, const hasher& hf = hasher(),
55 const key_equal& eql = key_equal(),
56 const allocator_type& a = allocator_type());
59 size_type n = 0, const hasher& hf = hasher(),
60 const key_equal& eql = key_equal(),
61 const allocator_type& a = allocator_type());
62 explicit unordered_map(const allocator_type&);
63 unordered_map(const unordered_map&);
64 unordered_map(const unordered_map&, const Allocator&);
70 unordered_map(unordered_map&&, const Allocator&);
72 const hasher& hf = hasher(), const key_equal& eql = key_equal(),
73 const allocator_type& a = allocator_type());
74 unordered_map(size_type n, const allocator_type& a)
76 unordered_map(size_type n, const hasher& hf, const allocator_type& a)
79 unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
82 unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
83 const allocator_type& a)
85 unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
87 unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
88 const allocator_type& a)
91 unordered_map& operator=(const unordered_map&);
100 allocator_type get_allocator() const noexcept;
102 bool empty() const noexcept;
103 size_type size() const noexcept;
104 size_type max_size() const noexcept;
108 const_iterator begin() const noexcept;
109 const_iterator end() const noexcept;
110 const_iterator cbegin() const noexcept;
111 const_iterator cend() const noexcept;
117 pair<iterator, bool> insert(const value_type& obj);
120 iterator insert(const_iterator hint, const value_type& obj);
128 node_type extract(const key_type& x); // C++17
133 pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17
137 iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
141 pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17
145 iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17
151 size_type erase(const key_type& k);
171 hasher hash_function() const;
172 key_equal key_eq() const;
174 iterator find(const key_type& k);
175 const_iterator find(const key_type& k) const;
177 iterator find(const K& x); // C++20
179 const_iterator find(const K& x) const; // C++20
180 size_type count(const key_type& k) const;
182 size_type count(const K& k) const; // C++20
183 bool contains(const key_type& k) const; // C++20
185 bool contains(const K& k) const; // C++20
186 pair<iterator, iterator> equal_range(const key_type& k);
187 pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
189 pair<iterator, iterator> equal_range(const K& k); // C++20
191 pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
193 mapped_type& operator[](const key_type& k);
196 mapped_type& at(const key_type& k);
197 const mapped_type& at(const key_type& k) const;
199 size_type bucket_count() const noexcept;
200 size_type max_bucket_count() const noexcept;
202 size_type bucket_size(size_type n) const;
203 size_type bucket(const key_type& k) const;
207 const_local_iterator begin(size_type n) const;
208 const_local_iterator end(size_type n) const;
209 const_local_iterator cbegin(size_type n) const;
210 const_local_iterator cend(size_type n) const;
212 float load_factor() const noexcept;
213 float max_load_factor() const noexcept;
228 class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
229 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
249 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
253 unordered_map(initializer_list<pair<const Key, T>>, Allocator)
257 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Hash, Allocator)
267 operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
268 const unordered_map<Key, T, Hash, Pred, Alloc>& y);
272 operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
273 const unordered_map<Key, T, Hash, Pred, Alloc>& y);
276 class Alloc = allocator<pair<const Key, T>>>
286 typedef pair<const key_type, mapped_type> value_type;
288 typedef const value_type& const_reference;
306 explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
307 const key_equal& eql = key_equal(),
308 const allocator_type& a = allocator_type());
311 size_type n = 0, const hasher& hf = hasher(),
312 const key_equal& eql = key_equal(),
313 const allocator_type& a = allocator_type());
314 explicit unordered_multimap(const allocator_type&);
315 unordered_multimap(const unordered_multimap&);
316 unordered_multimap(const unordered_multimap&, const Allocator&);
322 unordered_multimap(unordered_multimap&&, const Allocator&);
324 const hasher& hf = hasher(), const key_equal& eql = key_equal(),
325 const allocator_type& a = allocator_type());
326 unordered_multimap(size_type n, const allocator_type& a)
328 unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
331 unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
334 unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
335 const allocator_type& a)
337 unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
339 unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
340 const allocator_type& a)
343 unordered_multimap& operator=(const unordered_multimap&);
352 allocator_type get_allocator() const noexcept;
354 bool empty() const noexcept;
355 size_type size() const noexcept;
356 size_type max_size() const noexcept;
360 const_iterator begin() const noexcept;
361 const_iterator end() const noexcept;
362 const_iterator cbegin() const noexcept;
363 const_iterator cend() const noexcept;
369 iterator insert(const value_type& obj);
372 iterator insert(const_iterator hint, const value_type& obj);
380 node_type extract(const key_type& x); // C++17
386 size_type erase(const key_type& k);
406 hasher hash_function() const;
407 key_equal key_eq() const;
409 iterator find(const key_type& k);
410 const_iterator find(const key_type& k) const;
412 iterator find(const K& x); // C++20
414 const_iterator find(const K& x) const; // C++20
415 size_type count(const key_type& k) const;
417 size_type count(const K& k) const; // C++20
418 bool contains(const key_type& k) const; // C++20
420 bool contains(const K& k) const; // C++20
421 pair<iterator, iterator> equal_range(const key_type& k);
422 pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
424 pair<iterator, iterator> equal_range(const K& k); // C++20
426 pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
428 size_type bucket_count() const noexcept;
429 size_type max_bucket_count() const noexcept;
431 size_type bucket_size(size_type n) const;
432 size_type bucket(const key_type& k) const;
436 const_local_iterator begin(size_type n) const;
437 const_local_iterator end(size_type n) const;
438 const_local_iterator cbegin(size_type n) const;
439 const_local_iterator cend(size_type n) const;
441 float load_factor() const noexcept;
442 float max_load_factor() const noexcept;
457 class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
458 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
478 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
482 unordered_multimap(initializer_list<pair<const Key, T>>, Allocator)
486 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Hash,
505 operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
506 const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
510 operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
511 const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
570 __unordered_map_hasher(const _Hash& __h)
574 const _Hash& hash_function() const _NOEXCEPT {return *this;}
576 size_t operator()(const _Cp& __x) const
577 {return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
579 size_t operator()(const _Key& __x) const
580 {return static_cast<const _Hash&>(*this)(__x);}
584 size_t operator()(const _K2& __x) const
585 {return static_cast<const _Hash&>(*this)(__x);}
606 __unordered_map_hasher(const _Hash& __h)
610 const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
612 size_t operator()(const _Cp& __x) const
615 size_t operator()(const _Key& __x) const
620 size_t operator()(const _K2& __x) const
653 __unordered_map_equal(const _Pred& __p)
657 const _Pred& key_eq() const _NOEXCEPT {return *this;}
659 bool operator()(const _Cp& __x, const _Cp& __y) const
660 {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
662 bool operator()(const _Cp& __x, const _Key& __y) const
663 {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
665 bool operator()(const _Key& __x, const _Cp& __y) const
666 {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
670 bool operator()(const _Cp& __x, const _K2& __y) const
671 {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
674 bool operator()(const _K2& __x, const _Cp& __y) const
675 {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
678 bool operator()(const _Key& __x, const _K2& __y) const
679 {return static_cast<const _Pred&>(*this)(__x, __y);}
682 bool operator()(const _K2& __x, const _Key& __y) const
683 {return static_cast<const _Pred&>(*this)(__x, __y);}
704 __unordered_map_equal(const _Pred& __p)
708 const _Pred& key_eq() const _NOEXCEPT {return __pred_;}
710 bool operator()(const _Cp& __x, const _Cp& __y) const
713 bool operator()(const _Cp& __x, const _Key& __y) const
716 bool operator()(const _Key& __x, const _Cp& __y) const
721 bool operator()(const _Cp& __x, const _K2& __y) const
725 bool operator()(const _K2& __x, const _Cp& __y) const
729 bool operator()(const _Key& __x, const _K2& __y) const
733 bool operator()(const _K2& __x, const _Key& __y) const
768 __hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
793 __hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
820 typedef pair<const key_type, mapped_type> value_type;
839 const value_type& __get_value() const
865 __hash_value_type& operator=(const __hash_value_type& __v)
889 __hash_value_type(const __hash_value_type& __v) = delete;
904 typedef pair<const key_type, mapped_type> value_type;
913 const value_type& __get_value() const { return __cc; }
942 reference operator*() const {return __i_->__get_value();}
944 pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
957 bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
960 bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
981 typedef const value_type& reference;
996 reference operator*() const {return __i_->__get_value();}
998 pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
1011 bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
1014 bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
1027 class _Alloc = allocator<pair<const _Key, _Tp> > >
1037 typedef pair<const key_type, mapped_type> value_type;
1039 typedef const value_type& const_reference;
1094 explicit unordered_map(size_type __n, const hasher& __hf = hasher(),
1095 const key_equal& __eql = key_equal());
1096 unordered_map(size_type __n, const hasher& __hf,
1097 const key_equal& __eql,
1098 const allocator_type& __a);
1103 size_type __n, const hasher& __hf = hasher(),
1104 const key_equal& __eql = key_equal());
1107 size_type __n, const hasher& __hf,
1108 const key_equal& __eql,
1109 const allocator_type& __a);
1111 explicit unordered_map(const allocator_type& __a);
1112 unordered_map(const unordered_map& __u);
1113 unordered_map(const unordered_map& __u, const allocator_type& __a);
1118 unordered_map(unordered_map&& __u, const allocator_type& __a);
1121 const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
1123 const hasher& __hf, const key_equal& __eql,
1124 const allocator_type& __a);
1128 unordered_map(size_type __n, const allocator_type& __a)
1131 unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
1135 …unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& …
1139 … unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
1140 const allocator_type& __a)
1143 unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
1146 unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
1147 const allocator_type& __a)
1156 unordered_map& operator=(const unordered_map& __u)
1181 allocator_type get_allocator() const _NOEXCEPT
1185 bool empty() const _NOEXCEPT {return __table_.size() == 0;}
1187 size_type size() const _NOEXCEPT {return __table_.size();}
1189 size_type max_size() const _NOEXCEPT {return __table_.max_size();}
1196 const_iterator begin() const _NOEXCEPT {return __table_.begin();}
1198 const_iterator end() const _NOEXCEPT {return __table_.end();}
1200 const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
1202 const_iterator cend() const _NOEXCEPT {return __table_.end();}
1205 pair<iterator, bool> insert(const value_type& __x)
1208 iterator insert(const_iterator __p, const value_type& __x) {
1210 … "unordered_map::insert(const_iterator, const value_type&) called with an iterator not "
1231 … "unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
1276 pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
1294 iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
1316 pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
1340 iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v)
1360 size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
1385 node_type extract(key_type const& __key)
1436 hasher hash_function() const
1439 key_equal key_eq() const
1443 iterator find(const key_type& __k) {return __table_.find(__k);}
1445 const_iterator find(const key_type& __k) const {return __table_.find(__k);}
1449 iterator find(const _K2& __k) {return __table_.find(__k);}
1452 const_iterator find(const _K2& __k) const {return __table_.find(__k);}
1456 size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
1460 size_type count(const _K2& __k) const {return __table_.__count_unique(__k);}
1465 bool contains(const key_type& __k) const {return find(__k) != end();}
1469 bool contains(const _K2& __k) const {return find(__k) != end();}
1473 pair<iterator, iterator> equal_range(const key_type& __k)
1476 pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
1481 pair<iterator, iterator> equal_range(const _K2& __k)
1485 pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
1489 mapped_type& operator[](const key_type& __k);
1494 mapped_type& at(const key_type& __k);
1495 const mapped_type& at(const key_type& __k) const;
1498 size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
1500 size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
1503 size_type bucket_size(size_type __n) const
1506 size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
1513 const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
1515 const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
1517 const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
1519 const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
1522 float load_factor() const _NOEXCEPT {return __table_.load_factor();}
1524 float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
1534 bool __dereferenceable(const const_iterator* __i) const
1536 bool __decrementable(const const_iterator* __i) const
1538 bool __addable(const const_iterator* __i, ptrdiff_t __n) const
1540 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
1548 __node_holder __construct_node_with_key(const key_type& __k);
1568 class _Allocator = allocator<pair<const _Key, _Tp>>,
1625 size_type __n, const hasher& __hf, const key_equal& __eql)
1634 size_type __n, const hasher& __hf, const key_equal& __eql,
1635 const allocator_type& __a)
1645 const allocator_type& __a)
1664 const hasher& __hf, const key_equal& __eql)
1676 const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
1686 const unordered_map& __u)
1696 const unordered_map& __u, const allocator_type& __a)
1719 unordered_map&& __u, const allocator_type& __a)
1745 initializer_list<value_type> __il, size_type __n, const hasher& __hf,
1746 const key_equal& __eql)
1756 initializer_list<value_type> __il, size_type __n, const hasher& __hf,
1757 const key_equal& __eql, const allocator_type& __a)
1802 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
1821 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
1834 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
1849 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
1858 const _Tp&
1859 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
1890 operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
1891 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
1910 operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
1911 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
1917 class _Alloc = allocator<pair<const _Key, _Tp> > >
1927 typedef pair<const key_type, mapped_type> value_type;
1929 typedef const value_type& const_reference;
1981 explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(),
1982 const key_equal& __eql = key_equal());
1983 unordered_multimap(size_type __n, const hasher& __hf,
1984 const key_equal& __eql,
1985 const allocator_type& __a);
1990 size_type __n, const hasher& __hf = hasher(),
1991 const key_equal& __eql = key_equal());
1994 size_type __n, const hasher& __hf,
1995 const key_equal& __eql,
1996 const allocator_type& __a);
1998 explicit unordered_multimap(const allocator_type& __a);
1999 unordered_multimap(const unordered_multimap& __u);
2000 unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
2005 unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
2008 const hasher& __hf = hasher(),
2009 const key_equal& __eql = key_equal());
2011 const hasher& __hf, const key_equal& __eql,
2012 const allocator_type& __a);
2016 unordered_multimap(size_type __n, const allocator_type& __a)
2019 unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
2023 …unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_t…
2027 …unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __h…
2028 const allocator_type& __a)
2031 unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
2034 unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
2035 const allocator_type& __a)
2044 unordered_multimap& operator=(const unordered_multimap& __u)
2069 allocator_type get_allocator() const _NOEXCEPT
2073 bool empty() const _NOEXCEPT {return __table_.size() == 0;}
2075 size_type size() const _NOEXCEPT {return __table_.size();}
2077 size_type max_size() const _NOEXCEPT {return __table_.max_size();}
2084 const_iterator begin() const _NOEXCEPT {return __table_.begin();}
2086 const_iterator end() const _NOEXCEPT {return __table_.end();}
2088 const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
2090 const_iterator cend() const _NOEXCEPT {return __table_.end();}
2093 iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
2096 iterator insert(const_iterator __p, const value_type& __x)
2143 size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
2168 node_type extract(key_type const& __key)
2219 hasher hash_function() const
2222 key_equal key_eq() const
2226 iterator find(const key_type& __k) {return __table_.find(__k);}
2228 const_iterator find(const key_type& __k) const {return __table_.find(__k);}
2232 iterator find(const _K2& __k) {return __table_.find(__k);}
2235 const_iterator find(const _K2& __k) const {return __table_.find(__k);}
2239 size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
2243 size_type count(const _K2& __k) const {return __table_.__count_multi(__k);}
2248 bool contains(const key_type& __k) const {return find(__k) != end();}
2252 bool contains(const _K2& __k) const {return find(__k) != end();}
2256 pair<iterator, iterator> equal_range(const key_type& __k)
2259 pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
2264 pair<iterator, iterator> equal_range(const _K2& __k)
2268 pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
2273 size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
2275 size_type max_bucket_count() const _NOEXCEPT
2279 size_type bucket_size(size_type __n) const
2282 size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
2289 const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
2291 const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
2293 const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
2295 const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
2298 float load_factor() const _NOEXCEPT {return __table_.load_factor();}
2300 float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
2310 bool __dereferenceable(const const_iterator* __i) const
2312 bool __decrementable(const const_iterator* __i) const
2314 bool __addable(const const_iterator* __i, ptrdiff_t __n) const
2316 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
2340 class _Allocator = allocator<pair<const _Key, _Tp>>,
2397 size_type __n, const hasher& __hf, const key_equal& __eql)
2406 size_type __n, const hasher& __hf, const key_equal& __eql,
2407 const allocator_type& __a)
2427 const hasher& __hf, const key_equal& __eql)
2439 const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
2450 const allocator_type& __a)
2458 const unordered_multimap& __u)
2468 const unordered_multimap& __u, const allocator_type& __a)
2491 unordered_multimap&& __u, const allocator_type& __a)
2518 initializer_list<value_type> __il, size_type __n, const hasher& __hf,
2519 const key_equal& __eql)
2529 initializer_list<value_type> __il, size_type __n, const hasher& __hf,
2530 const key_equal& __eql, const allocator_type& __a)
2596 operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
2597 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
2620 operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
2621 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)