30 #ifndef _UNORDERED_SET_H
31 #define _UNORDERED_SET_H
33 namespace std _GLIBCXX_VISIBILITY(default)
35 _GLIBCXX_BEGIN_NAMESPACE_VERSION
36 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
42 template<
typename _Value,
48 __detail::_Identity, _Pred, _Hash,
57 template<
typename _Value,
69 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
93 template<
typename _Value,
107 typedef typename _Hashtable::value_type value_type;
108 typedef typename _Hashtable::hasher hasher;
109 typedef typename _Hashtable::key_equal key_equal;
110 typedef typename _Hashtable::allocator_type allocator_type;
116 typedef typename _Hashtable::const_pointer const_pointer;
117 typedef typename _Hashtable::reference reference;
118 typedef typename _Hashtable::const_reference const_reference;
119 typedef typename _Hashtable::iterator iterator;
120 typedef typename _Hashtable::const_iterator const_iterator;
123 typedef typename _Hashtable::size_type size_type;
124 typedef typename _Hashtable::difference_type difference_type;
127 #if __cplusplus > 201402L
146 const hasher& __hf = hasher(),
147 const key_equal& __eql = key_equal(),
148 const allocator_type& __a = allocator_type())
149 : _M_h(__n, __hf, __eql, __a)
165 template<
typename _InputIterator>
168 const hasher& __hf = hasher(),
169 const key_equal& __eql = key_equal(),
170 const allocator_type& __a = allocator_type())
171 : _M_h(__first, __last, __n, __hf, __eql, __a)
195 const allocator_type& __a)
196 : _M_h(__uset._M_h, __a)
205 const allocator_type& __a)
206 noexcept( noexcept(_Hashtable(
std::move(__uset._M_h), __a)) )
207 : _M_h(
std::
move(__uset._M_h), __a)
223 const hasher& __hf = hasher(),
224 const key_equal& __eql = key_equal(),
225 const allocator_type& __a = allocator_type())
226 : _M_h(__l, __n, __hf, __eql, __a)
234 const allocator_type& __a)
238 template<
typename _InputIterator>
241 const allocator_type& __a)
242 :
unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
245 template<
typename _InputIterator>
247 size_type __n,
const hasher& __hf,
248 const allocator_type& __a)
249 :
unordered_set(__first, __last, __n, __hf, key_equal(), __a)
254 const allocator_type& __a)
259 size_type __n,
const hasher& __hf,
260 const allocator_type& __a)
293 {
return _M_h.get_allocator(); }
298 _GLIBCXX_NODISCARD
bool
300 {
return _M_h.empty(); }
305 {
return _M_h.size(); }
310 {
return _M_h.max_size(); }
321 {
return _M_h.begin(); }
324 begin() const noexcept
325 {
return _M_h.begin(); }
335 {
return _M_h.end(); }
339 {
return _M_h.end(); }
348 {
return _M_h.begin(); }
356 {
return _M_h.end(); }
375 template<
typename... _Args>
378 {
return _M_h.emplace(std::forward<_Args>(__args)...); }
401 template<
typename... _Args>
404 {
return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
422 {
return _M_h.insert(__x); }
450 insert(const_iterator __hint,
const value_type& __x)
451 {
return _M_h.insert(__hint, __x); }
454 insert(const_iterator __hint, value_type&& __x)
455 {
return _M_h.insert(__hint,
std::move(__x)); }
467 template<
typename _InputIterator>
469 insert(_InputIterator __first, _InputIterator __last)
470 { _M_h.insert(__first, __last); }
481 { _M_h.insert(__l); }
483 #if __cplusplus > 201402L
488 __glibcxx_assert(__pos !=
end());
489 return _M_h.extract(__pos);
495 {
return _M_h.extract(__key); }
524 {
return _M_h.erase(__position); }
529 {
return _M_h.erase(__position); }
546 {
return _M_h.erase(__x); }
563 erase(const_iterator __first, const_iterator __last)
564 {
return _M_h.erase(__first, __last); }
587 noexcept( noexcept(_M_h.swap(__x._M_h)) )
588 { _M_h.swap(__x._M_h); }
590 #if __cplusplus > 201402L
591 template<
typename,
typename,
typename>
592 friend class std::_Hash_merge_helper;
594 template<
typename _H2,
typename _P2>
598 using _Merge_helper = _Hash_merge_helper<unordered_set, _H2, _P2>;
602 template<
typename _H2,
typename _P2>
604 merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source)
607 template<
typename _H2,
typename _P2>
609 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>& __source)
611 using _Merge_helper = _Hash_merge_helper<unordered_set, _H2, _P2>;
615 template<
typename _H2,
typename _P2>
617 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source)
627 {
return _M_h.hash_function(); }
633 {
return _M_h.key_eq(); }
651 {
return _M_h.find(__x); }
655 {
return _M_h.find(__x); }
669 {
return _M_h.count(__x); }
671 #if __cplusplus > 201703L
679 {
return _M_h.find(__x) != _M_h.end(); }
693 {
return _M_h.equal_range(__x); }
697 {
return _M_h.equal_range(__x); }
705 {
return _M_h.bucket_count(); }
710 {
return _M_h.max_bucket_count(); }
718 bucket_size(size_type __n)
const
719 {
return _M_h.bucket_size(__n); }
728 {
return _M_h.bucket(__key); }
739 {
return _M_h.begin(__n); }
742 begin(size_type __n)
const
743 {
return _M_h.begin(__n); }
746 cbegin(size_type __n)
const
747 {
return _M_h.cbegin(__n); }
759 {
return _M_h.end(__n); }
762 end(size_type __n)
const
763 {
return _M_h.end(__n); }
766 cend(size_type __n)
const
767 {
return _M_h.cend(__n); }
775 {
return _M_h.load_factor(); }
781 {
return _M_h.max_load_factor(); }
789 { _M_h.max_load_factor(__z); }
800 { _M_h.rehash(__n); }
811 { _M_h.reserve(__n); }
813 template<
typename _Value1,
typename _Hash1,
typename _Pred1,
820 #if __cpp_deduction_guides >= 201606
822 template<
typename _InputIterator,
824 hash<typename iterator_traits<_InputIterator>::value_type>,
826 equal_to<typename iterator_traits<_InputIterator>::value_type>,
827 typename _Allocator =
828 allocator<typename iterator_traits<_InputIterator>::value_type>,
829 typename = _RequireInputIter<_InputIterator>,
830 typename = _RequireNotAllocatorOrIntegral<_Hash>,
831 typename = _RequireNotAllocator<_Pred>,
832 typename = _RequireAllocator<_Allocator>>
833 unordered_set(_InputIterator, _InputIterator,
834 unordered_set<int>::size_type = {},
835 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
836 -> unordered_set<
typename iterator_traits<_InputIterator>::value_type,
837 _Hash, _Pred, _Allocator>;
839 template<
typename _Tp,
typename _Hash = hash<_Tp>,
840 typename _Pred = equal_to<_Tp>,
841 typename _Allocator = allocator<_Tp>,
842 typename = _RequireNotAllocatorOrIntegral<_Hash>,
843 typename = _RequireNotAllocator<_Pred>,
844 typename = _RequireAllocator<_Allocator>>
845 unordered_set(initializer_list<_Tp>,
846 unordered_set<int>::size_type = {},
847 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
848 -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
850 template<
typename _InputIterator,
typename _Allocator,
851 typename = _RequireInputIter<_InputIterator>,
852 typename = _RequireAllocator<_Allocator>>
853 unordered_set(_InputIterator, _InputIterator,
854 unordered_set<int>::size_type, _Allocator)
855 -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
857 typename iterator_traits<_InputIterator>::value_type>,
859 typename iterator_traits<_InputIterator>::value_type>,
862 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
863 typename = _RequireInputIter<_InputIterator>,
864 typename = _RequireNotAllocatorOrIntegral<_Hash>,
865 typename = _RequireAllocator<_Allocator>>
866 unordered_set(_InputIterator, _InputIterator,
867 unordered_set<int>::size_type,
869 -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
872 typename iterator_traits<_InputIterator>::value_type>,
875 template<
typename _Tp,
typename _Allocator,
876 typename = _RequireAllocator<_Allocator>>
877 unordered_set(initializer_list<_Tp>,
878 unordered_set<int>::size_type, _Allocator)
879 -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
881 template<
typename _Tp,
typename _Hash,
typename _Allocator,
882 typename = _RequireNotAllocatorOrIntegral<_Hash>,
883 typename = _RequireAllocator<_Allocator>>
884 unordered_set(initializer_list<_Tp>,
885 unordered_set<int>::size_type, _Hash, _Allocator)
886 -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
909 template<
typename _Value,
910 typename _Hash = hash<_Value>,
911 typename _Pred = equal_to<_Value>,
912 typename _Alloc = allocator<_Value>>
923 typedef typename _Hashtable::value_type value_type;
924 typedef typename _Hashtable::hasher hasher;
925 typedef typename _Hashtable::key_equal key_equal;
926 typedef typename _Hashtable::allocator_type allocator_type;
932 typedef typename _Hashtable::const_pointer const_pointer;
933 typedef typename _Hashtable::reference reference;
934 typedef typename _Hashtable::const_reference const_reference;
935 typedef typename _Hashtable::iterator iterator;
936 typedef typename _Hashtable::const_iterator const_iterator;
939 typedef typename _Hashtable::size_type size_type;
940 typedef typename _Hashtable::difference_type difference_type;
943 #if __cplusplus > 201402L
961 const hasher& __hf = hasher(),
962 const key_equal& __eql = key_equal(),
963 const allocator_type& __a = allocator_type())
964 : _M_h(__n, __hf, __eql, __a)
980 template<
typename _InputIterator>
983 const hasher& __hf = hasher(),
984 const key_equal& __eql = key_equal(),
985 const allocator_type& __a = allocator_type())
986 : _M_h(__first, __last, __n, __hf, __eql, __a)
1008 const hasher& __hf = hasher(),
1009 const key_equal& __eql = key_equal(),
1010 const allocator_type& __a = allocator_type())
1011 : _M_h(__l, __n, __hf, __eql, __a)
1037 const allocator_type& __a)
1038 : _M_h(__umset._M_h, __a)
1047 const allocator_type& __a)
1048 noexcept( noexcept(_Hashtable(
std::move(__umset._M_h), __a)) )
1049 : _M_h(
std::
move(__umset._M_h), __a)
1057 const allocator_type& __a)
1061 template<
typename _InputIterator>
1064 const allocator_type& __a)
1068 template<
typename _InputIterator>
1070 size_type __n,
const hasher& __hf,
1071 const allocator_type& __a)
1077 const allocator_type& __a)
1082 size_type __n,
const hasher& __hf,
1083 const allocator_type& __a)
1108 {
return _M_h.get_allocator(); }
1113 _GLIBCXX_NODISCARD
bool
1115 {
return _M_h.empty(); }
1120 {
return _M_h.size(); }
1125 {
return _M_h.max_size(); }
1136 {
return _M_h.begin(); }
1139 begin() const noexcept
1140 {
return _M_h.begin(); }
1150 {
return _M_h.end(); }
1153 end() const noexcept
1154 {
return _M_h.end(); }
1163 {
return _M_h.begin(); }
1171 {
return _M_h.end(); }
1182 template<
typename... _Args>
1185 {
return _M_h.emplace(std::forward<_Args>(__args)...); }
1204 template<
typename... _Args>
1207 {
return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
1219 {
return _M_h.insert(__x); }
1244 insert(const_iterator __hint,
const value_type& __x)
1245 {
return _M_h.insert(__hint, __x); }
1248 insert(const_iterator __hint, value_type&& __x)
1249 {
return _M_h.insert(__hint,
std::move(__x)); }
1260 template<
typename _InputIterator>
1262 insert(_InputIterator __first, _InputIterator __last)
1263 { _M_h.insert(__first, __last); }
1274 { _M_h.insert(__l); }
1276 #if __cplusplus > 201402L
1281 __glibcxx_assert(__pos !=
end());
1282 return _M_h.extract(__pos);
1288 {
return _M_h.extract(__key); }
1297 insert(const_iterator __hint, node_type&& __nh)
1318 {
return _M_h.erase(__position); }
1323 {
return _M_h.erase(__position); }
1341 {
return _M_h.erase(__x); }
1360 erase(const_iterator __first, const_iterator __last)
1361 {
return _M_h.erase(__first, __last); }
1385 noexcept( noexcept(_M_h.swap(__x._M_h)) )
1386 { _M_h.swap(__x._M_h); }
1388 #if __cplusplus > 201402L
1389 template<
typename,
typename,
typename>
1390 friend class std::_Hash_merge_helper;
1392 template<
typename _H2,
typename _P2>
1397 = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
1401 template<
typename _H2,
typename _P2>
1403 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source)
1404 { merge(__source); }
1406 template<
typename _H2,
typename _P2>
1408 merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source)
1411 = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
1415 template<
typename _H2,
typename _P2>
1417 merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source)
1418 { merge(__source); }
1427 {
return _M_h.hash_function(); }
1433 {
return _M_h.key_eq(); }
1451 {
return _M_h.find(__x); }
1455 {
return _M_h.find(__x); }
1465 {
return _M_h.count(__x); }
1467 #if __cplusplus > 201703L
1474 contains(
const key_type& __x)
const
1475 {
return _M_h.find(__x) != _M_h.end(); }
1487 {
return _M_h.equal_range(__x); }
1491 {
return _M_h.equal_range(__x); }
1499 {
return _M_h.bucket_count(); }
1504 {
return _M_h.max_bucket_count(); }
1512 bucket_size(size_type __n)
const
1513 {
return _M_h.bucket_size(__n); }
1521 bucket(
const key_type& __key)
const
1522 {
return _M_h.bucket(__key); }
1533 {
return _M_h.begin(__n); }
1535 const_local_iterator
1536 begin(size_type __n)
const
1537 {
return _M_h.begin(__n); }
1539 const_local_iterator
1540 cbegin(size_type __n)
const
1541 {
return _M_h.cbegin(__n); }
1553 {
return _M_h.end(__n); }
1555 const_local_iterator
1556 end(size_type __n)
const
1557 {
return _M_h.end(__n); }
1559 const_local_iterator
1560 cend(size_type __n)
const
1561 {
return _M_h.cend(__n); }
1569 {
return _M_h.load_factor(); }
1575 {
return _M_h.max_load_factor(); }
1583 { _M_h.max_load_factor(__z); }
1594 { _M_h.rehash(__n); }
1605 { _M_h.reserve(__n); }
1607 template<
typename _Value1,
typename _Hash1,
typename _Pred1,
1615 #if __cpp_deduction_guides >= 201606
1617 template<
typename _InputIterator,
1619 hash<typename iterator_traits<_InputIterator>::value_type>,
1621 equal_to<typename iterator_traits<_InputIterator>::value_type>,
1622 typename _Allocator =
1623 allocator<typename iterator_traits<_InputIterator>::value_type>,
1624 typename = _RequireInputIter<_InputIterator>,
1625 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1626 typename = _RequireNotAllocator<_Pred>,
1627 typename = _RequireAllocator<_Allocator>>
1628 unordered_multiset(_InputIterator, _InputIterator,
1629 unordered_multiset<int>::size_type = {},
1630 _Hash = _Hash(), _Pred = _Pred(),
1631 _Allocator = _Allocator())
1632 -> unordered_multiset<
typename iterator_traits<_InputIterator>::value_type,
1633 _Hash, _Pred, _Allocator>;
1635 template<
typename _Tp,
typename _Hash = hash<_Tp>,
1636 typename _Pred = equal_to<_Tp>,
1637 typename _Allocator = allocator<_Tp>,
1638 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1639 typename = _RequireNotAllocator<_Pred>,
1640 typename = _RequireAllocator<_Allocator>>
1641 unordered_multiset(initializer_list<_Tp>,
1642 unordered_multiset<int>::size_type = {},
1643 _Hash = _Hash(), _Pred = _Pred(),
1644 _Allocator = _Allocator())
1645 -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
1647 template<
typename _InputIterator,
typename _Allocator,
1648 typename = _RequireInputIter<_InputIterator>,
1649 typename = _RequireAllocator<_Allocator>>
1650 unordered_multiset(_InputIterator, _InputIterator,
1651 unordered_multiset<int>::size_type, _Allocator)
1652 -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
1654 iterator_traits<_InputIterator>::value_type>,
1656 iterator_traits<_InputIterator>::value_type>,
1659 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
1660 typename = _RequireInputIter<_InputIterator>,
1661 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1662 typename = _RequireAllocator<_Allocator>>
1663 unordered_multiset(_InputIterator, _InputIterator,
1664 unordered_multiset<int>::size_type,
1666 -> unordered_multiset<
typename
1667 iterator_traits<_InputIterator>::value_type,
1671 iterator_traits<_InputIterator>::value_type>,
1674 template<
typename _Tp,
typename _Allocator,
1675 typename = _RequireAllocator<_Allocator>>
1676 unordered_multiset(initializer_list<_Tp>,
1677 unordered_multiset<int>::size_type, _Allocator)
1678 -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
1680 template<
typename _Tp,
typename _Hash,
typename _Allocator,
1681 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1682 typename = _RequireAllocator<_Allocator>>
1683 unordered_multiset(initializer_list<_Tp>,
1684 unordered_multiset<int>::size_type, _Hash, _Allocator)
1685 -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
1689 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1691 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1692 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1693 noexcept(noexcept(__x.swap(__y)))
1696 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1698 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1699 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1700 noexcept(noexcept(__x.swap(__y)))
1703 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1705 operator==(
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1706 const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1707 {
return __x._M_h._M_equal(__y._M_h); }
1709 #if __cpp_impl_three_way_comparison < 201907L
1710 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1712 operator!=(
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1713 const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1714 {
return !(__x == __y); }
1717 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1719 operator==(
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1720 const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1721 {
return __x._M_h._M_equal(__y._M_h); }
1723 #if __cpp_impl_three_way_comparison < 201907L
1724 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1726 operator!=(
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1727 const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1728 {
return !(__x == __y); }
1731 _GLIBCXX_END_NAMESPACE_CONTAINER
1733 #if __cplusplus > 201402L
1735 template<
typename _Val,
typename _Hash1,
typename _Eq1,
typename _Alloc,
1736 typename _Hash2,
typename _Eq2>
1737 struct _Hash_merge_helper<
1738 _GLIBCXX_STD_C::unordered_set<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2>
1741 template<
typename... _Tp>
1742 using unordered_set = _GLIBCXX_STD_C::unordered_set<_Tp...>;
1743 template<
typename... _Tp>
1744 using unordered_multiset = _GLIBCXX_STD_C::unordered_multiset<_Tp...>;
1746 friend unordered_set<_Val, _Hash1, _Eq1, _Alloc>;
1749 _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
1750 {
return __set._M_h; }
1753 _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
1754 {
return __set._M_h; }
1758 template<
typename _Val,
typename _Hash1,
typename _Eq1,
typename _Alloc,
1759 typename _Hash2,
typename _Eq2>
1760 struct _Hash_merge_helper<
1761 _GLIBCXX_STD_C::unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>,
1765 template<
typename... _Tp>
1766 using unordered_set = _GLIBCXX_STD_C::unordered_set<_Tp...>;
1767 template<
typename... _Tp>
1768 using unordered_multiset = _GLIBCXX_STD_C::unordered_multiset<_Tp...>;
1770 friend unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>;
1773 _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
1774 {
return __set._M_h; }
1777 _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
1778 {
return __set._M_h; }
1782 _GLIBCXX_END_NAMESPACE_VERSION
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
ISO C++ entities toplevel namespace is std.
Primary class template hash.
The standard allocator, as per [20.4].
void _M_merge_unique(_Compatible_Hashtable &__src) noexcept
Merge from a compatible container into one with unique keys.
void _M_merge_multi(_Compatible_Hashtable &__src) noexcept
Merge from a compatible container into one with equivalent keys.
insert_return_type _M_reinsert_node(node_type &&__nh)
Re-insert an extracted node into a container with unique keys.
iterator _M_reinsert_node_multi(const_iterator __hint, node_type &&__nh)
Re-insert an extracted node into a container with equivalent keys.
Default range hashing function: use division to fold a large number into the range [0,...
Default ranged hash function H. In principle it should be a function object composed from objects of ...
Default value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load fact...
Node handle type for maps.
Return type of insert(node_handle&&) on unique maps/sets.
One of the comparison functors.
Struct holding two objects of arbitrary type.
A standard container composed of equivalent keys (possibly containing multiple of each key value) in ...
iterator begin() noexcept
iterator insert(const_iterator __hint, const value_type &__x)
Inserts an element into the unordered_multiset.
void insert(initializer_list< value_type > __l)
Inserts a list of elements into the unordered_multiset.
_Hashtable::pointer pointer
Iterator-related typedefs.
void rehash(size_type __n)
May rehash the unordered_multiset.
local_iterator begin(size_type __n)
Returns a read-only (constant) iterator pointing to the first bucket element.
std::pair< iterator, iterator > equal_range(const key_type &__x)
Finds a subsequence matching given key.
size_type bucket_count() const noexcept
Returns the number of buckets of the unordered_multiset.
float max_load_factor() const noexcept
Returns a positive number that the unordered_multiset tries to keep the load factor less than or equa...
bool empty() const noexcept
Returns true if the unordered_multiset is empty.
const_iterator cend() const noexcept
node_type extract(const key_type &__key)
Extract a node.
iterator emplace(_Args &&... __args)
Builds and insert an element into the unordered_multiset.
unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Builds an unordered_multiset from a range.
unordered_multiset(const allocator_type &__a)
Creates an unordered_multiset with no elements.
iterator find(const key_type &__x)
Tries to locate an element in an unordered_multiset.
float load_factor() const noexcept
Returns the average number of elements per bucket.
unordered_multiset()=default
Default constructor.
iterator insert(const_iterator __hint, node_type &&__nh)
Re-insert an extracted node.
_Hashtable::key_type key_type
Public typedefs.
hasher hash_function() const
Returns the hash functor object with which the unordered_multiset was constructed.
unordered_multiset(initializer_list< value_type > __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Builds an unordered_multiset from an initializer_list.
size_type count(const key_type &__x) const
Finds the number of elements.
iterator erase(const_iterator __position)
Erases an element from an unordered_multiset.
unordered_multiset(unordered_multiset &&)=default
Move constructor.
iterator emplace_hint(const_iterator __pos, _Args &&... __args)
Inserts an element into the unordered_multiset.
void swap(unordered_multiset &__x) noexcept(noexcept(_M_h.swap(__x._M_h)))
Swaps data with another unordered_multiset.
iterator erase(const_iterator __first, const_iterator __last)
Erases a [__first,__last) range of elements from an unordered_multiset.
const_iterator cbegin() const noexcept
void insert(_InputIterator __first, _InputIterator __last)
A template function that inserts a range of elements.
key_equal key_eq() const
Returns the key comparison object with which the unordered_multiset was constructed.
unordered_multiset & operator=(const unordered_multiset &)=default
Copy assignment operator.
iterator insert(const value_type &__x)
Inserts an element into the unordered_multiset.
void reserve(size_type __n)
Prepare the unordered_multiset for a specified number of elements.
unordered_multiset & operator=(unordered_multiset &&)=default
Move assignment operator.
size_type max_bucket_count() const noexcept
Returns the maximum number of buckets of the unordered_multiset.
iterator insert(node_type &&__nh)
Re-insert an extracted node.
unordered_multiset(size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Default constructor creates no elements.
size_type size() const noexcept
Returns the size of the unordered_multiset.
local_iterator end(size_type __n)
Returns a read-only (constant) iterator pointing to one past the last bucket elements.
unordered_multiset & operator=(initializer_list< value_type > __l)
Unordered_multiset list assignment operator.
node_type extract(const_iterator __pos)
Extract a node.
size_type max_size() const noexcept
Returns the maximum size of the unordered_multiset.
unordered_multiset(const unordered_multiset &)=default
Copy constructor.
size_type erase(const key_type &__x)
Erases elements according to the provided key.
allocator_type get_allocator() const noexcept
Returns the allocator object used by the unordered_multiset.
void max_load_factor(float __z)
Change the unordered_multiset maximum load factor.
A standard container composed of unique keys (containing at most one of each key value) in which the ...
unordered_set(initializer_list< value_type > __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Builds an unordered_set from an initializer_list.
void max_load_factor(float __z)
Change the unordered_set maximum load factor.
const_iterator cend() const noexcept
_Hashtable::key_type key_type
Public typedefs.
size_type count(const key_type &__x) const
Finds the number of elements.
unordered_set & operator=(const unordered_set &)=default
Copy assignment operator.
unordered_set & operator=(initializer_list< value_type > __l)
Unordered_set list assignment operator.
insert_return_type insert(node_type &&__nh)
Re-insert an extracted node.
const_iterator cbegin() const noexcept
bool empty() const noexcept
Returns true if the unordered_set is empty.
unordered_set(unordered_set &&)=default
Move constructor.
unordered_set(const allocator_type &__a)
Creates an unordered_set with no elements.
void swap(unordered_set &__x) noexcept(noexcept(_M_h.swap(__x._M_h)))
Swaps data with another unordered_set.
iterator insert(const_iterator __hint, const value_type &__x)
Attempts to insert an element into the unordered_set.
float load_factor() const noexcept
Returns the average number of elements per bucket.
void rehash(size_type __n)
May rehash the unordered_set.
local_iterator end(size_type __n)
Returns a read-only (constant) iterator pointing to one past the last bucket elements.
size_type size() const noexcept
Returns the size of the unordered_set.
iterator insert(const_iterator, node_type &&__nh)
Re-insert an extracted node.
hasher hash_function() const
Returns the hash functor object with which the unordered_set was constructed.
unordered_set(const unordered_set &)=default
Copy constructor.
iterator emplace_hint(const_iterator __pos, _Args &&... __args)
Attempts to insert an element into the unordered_set.
key_equal key_eq() const
Returns the key comparison object with which the unordered_set was constructed.
node_type extract(const key_type &__key)
Extract a node.
local_iterator begin(size_type __n)
Returns a read-only (constant) iterator pointing to the first bucket element.
unordered_set()=default
Default constructor.
void insert(_InputIterator __first, _InputIterator __last)
A template function that attempts to insert a range of elements.
float max_load_factor() const noexcept
Returns a positive number that the unordered_set tries to keep the load factor less than or equal to.
size_type erase(const key_type &__x)
Erases elements according to the provided key.
std::pair< iterator, bool > insert(const value_type &__x)
Attempts to insert an element into the unordered_set.
unordered_set(size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Default constructor creates no elements.
iterator erase(const_iterator __first, const_iterator __last)
Erases a [__first,__last) range of elements from an unordered_set.
iterator erase(const_iterator __position)
Erases an element from an unordered_set.
allocator_type get_allocator() const noexcept
Returns the allocator object used by the unordered_set.
void insert(initializer_list< value_type > __l)
Attempts to insert a list of elements into the unordered_set.
unordered_set(_InputIterator __first, _InputIterator __last, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
Builds an unordered_set from a range.
unordered_set & operator=(unordered_set &&)=default
Move assignment operator.
std::pair< iterator, bool > emplace(_Args &&... __args)
Attempts to build and insert an element into the unordered_set.
size_type bucket_count() const noexcept
Returns the number of buckets of the unordered_set.
std::pair< iterator, iterator > equal_range(const key_type &__x)
Finds a subsequence matching given key.
void reserve(size_type __n)
Prepare the unordered_set for a specified number of elements.
node_type extract(const_iterator __pos)
Extract a node.
_Hashtable::pointer pointer
Iterator-related typedefs.
iterator begin() noexcept
iterator find(const key_type &__x)
Tries to locate an element in an unordered_set.
size_type max_size() const noexcept
Returns the maximum size of the unordered_set.
size_type max_bucket_count() const noexcept
Returns the maximum number of buckets of the unordered_set.