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); }
653 #if __cplusplus > 201703L
654 template<
typename _Kt>
657 -> decltype(_M_h._M_find_tr(__k))
658 {
return _M_h._M_find_tr(__k); }
663 {
return _M_h.find(__x); }
665 #if __cplusplus > 201703L
666 template<
typename _Kt>
668 find(
const _Kt& __k)
const
669 -> decltype(_M_h._M_find_tr(__k))
670 {
return _M_h._M_find_tr(__k); }
686 {
return _M_h.count(__x); }
688 #if __cplusplus > 201703L
689 template<
typename _Kt>
691 count(
const _Kt& __k)
const
692 -> decltype(_M_h._M_count_tr(__k))
693 {
return _M_h._M_count_tr(__k); }
697 #if __cplusplus > 201703L
706 {
return _M_h.find(__x) != _M_h.end(); }
708 template<
typename _Kt>
710 contains(
const _Kt& __k)
const
711 -> decltype(_M_h._M_find_tr(__k),
void(),
true)
712 {
return _M_h._M_find_tr(__k) != _M_h.end(); }
727 {
return _M_h.equal_range(__x); }
729 #if __cplusplus > 201703L
730 template<
typename _Kt>
733 -> decltype(_M_h._M_equal_range_tr(__k))
734 {
return _M_h._M_equal_range_tr(__k); }
739 {
return _M_h.equal_range(__x); }
741 #if __cplusplus > 201703L
742 template<
typename _Kt>
745 -> decltype(_M_h._M_equal_range_tr(__k))
746 {
return _M_h._M_equal_range_tr(__k); }
755 {
return _M_h.bucket_count(); }
760 {
return _M_h.max_bucket_count(); }
768 bucket_size(size_type __n)
const
769 {
return _M_h.bucket_size(__n); }
778 {
return _M_h.bucket(__key); }
789 {
return _M_h.begin(__n); }
792 begin(size_type __n)
const
793 {
return _M_h.begin(__n); }
796 cbegin(size_type __n)
const
797 {
return _M_h.cbegin(__n); }
809 {
return _M_h.end(__n); }
812 end(size_type __n)
const
813 {
return _M_h.end(__n); }
816 cend(size_type __n)
const
817 {
return _M_h.cend(__n); }
825 {
return _M_h.load_factor(); }
831 {
return _M_h.max_load_factor(); }
839 { _M_h.max_load_factor(__z); }
850 { _M_h.rehash(__n); }
861 { _M_h.reserve(__n); }
863 template<
typename _Value1,
typename _Hash1,
typename _Pred1,
870 #if __cpp_deduction_guides >= 201606
872 template<
typename _InputIterator,
874 hash<typename iterator_traits<_InputIterator>::value_type>,
876 equal_to<typename iterator_traits<_InputIterator>::value_type>,
877 typename _Allocator =
878 allocator<typename iterator_traits<_InputIterator>::value_type>,
879 typename = _RequireInputIter<_InputIterator>,
880 typename = _RequireNotAllocatorOrIntegral<_Hash>,
881 typename = _RequireNotAllocator<_Pred>,
882 typename = _RequireAllocator<_Allocator>>
883 unordered_set(_InputIterator, _InputIterator,
884 unordered_set<int>::size_type = {},
885 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
886 -> unordered_set<
typename iterator_traits<_InputIterator>::value_type,
887 _Hash, _Pred, _Allocator>;
889 template<
typename _Tp,
typename _Hash = hash<_Tp>,
890 typename _Pred = equal_to<_Tp>,
891 typename _Allocator = allocator<_Tp>,
892 typename = _RequireNotAllocatorOrIntegral<_Hash>,
893 typename = _RequireNotAllocator<_Pred>,
894 typename = _RequireAllocator<_Allocator>>
895 unordered_set(initializer_list<_Tp>,
896 unordered_set<int>::size_type = {},
897 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
898 -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
900 template<
typename _InputIterator,
typename _Allocator,
901 typename = _RequireInputIter<_InputIterator>,
902 typename = _RequireAllocator<_Allocator>>
903 unordered_set(_InputIterator, _InputIterator,
904 unordered_set<int>::size_type, _Allocator)
905 -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
907 typename iterator_traits<_InputIterator>::value_type>,
909 typename iterator_traits<_InputIterator>::value_type>,
912 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
913 typename = _RequireInputIter<_InputIterator>,
914 typename = _RequireNotAllocatorOrIntegral<_Hash>,
915 typename = _RequireAllocator<_Allocator>>
916 unordered_set(_InputIterator, _InputIterator,
917 unordered_set<int>::size_type,
919 -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
922 typename iterator_traits<_InputIterator>::value_type>,
925 template<
typename _Tp,
typename _Allocator,
926 typename = _RequireAllocator<_Allocator>>
927 unordered_set(initializer_list<_Tp>,
928 unordered_set<int>::size_type, _Allocator)
929 -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
931 template<
typename _Tp,
typename _Hash,
typename _Allocator,
932 typename = _RequireNotAllocatorOrIntegral<_Hash>,
933 typename = _RequireAllocator<_Allocator>>
934 unordered_set(initializer_list<_Tp>,
935 unordered_set<int>::size_type, _Hash, _Allocator)
936 -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
959 template<
typename _Value,
960 typename _Hash = hash<_Value>,
961 typename _Pred = equal_to<_Value>,
962 typename _Alloc = allocator<_Value>>
973 typedef typename _Hashtable::value_type value_type;
974 typedef typename _Hashtable::hasher hasher;
975 typedef typename _Hashtable::key_equal key_equal;
976 typedef typename _Hashtable::allocator_type allocator_type;
982 typedef typename _Hashtable::const_pointer const_pointer;
983 typedef typename _Hashtable::reference reference;
984 typedef typename _Hashtable::const_reference const_reference;
985 typedef typename _Hashtable::iterator iterator;
986 typedef typename _Hashtable::const_iterator const_iterator;
989 typedef typename _Hashtable::size_type size_type;
990 typedef typename _Hashtable::difference_type difference_type;
993 #if __cplusplus > 201402L
1011 const hasher& __hf = hasher(),
1012 const key_equal& __eql = key_equal(),
1013 const allocator_type& __a = allocator_type())
1014 : _M_h(__n, __hf, __eql, __a)
1030 template<
typename _InputIterator>
1033 const hasher& __hf = hasher(),
1034 const key_equal& __eql = key_equal(),
1035 const allocator_type& __a = allocator_type())
1036 : _M_h(__first, __last, __n, __hf, __eql, __a)
1058 const hasher& __hf = hasher(),
1059 const key_equal& __eql = key_equal(),
1060 const allocator_type& __a = allocator_type())
1061 : _M_h(__l, __n, __hf, __eql, __a)
1087 const allocator_type& __a)
1088 : _M_h(__umset._M_h, __a)
1097 const allocator_type& __a)
1098 noexcept( noexcept(_Hashtable(
std::move(__umset._M_h), __a)) )
1099 : _M_h(
std::
move(__umset._M_h), __a)
1107 const allocator_type& __a)
1111 template<
typename _InputIterator>
1114 const allocator_type& __a)
1118 template<
typename _InputIterator>
1120 size_type __n,
const hasher& __hf,
1121 const allocator_type& __a)
1127 const allocator_type& __a)
1132 size_type __n,
const hasher& __hf,
1133 const allocator_type& __a)
1158 {
return _M_h.get_allocator(); }
1163 _GLIBCXX_NODISCARD
bool
1165 {
return _M_h.empty(); }
1170 {
return _M_h.size(); }
1175 {
return _M_h.max_size(); }
1186 {
return _M_h.begin(); }
1189 begin() const noexcept
1190 {
return _M_h.begin(); }
1200 {
return _M_h.end(); }
1203 end() const noexcept
1204 {
return _M_h.end(); }
1213 {
return _M_h.begin(); }
1221 {
return _M_h.end(); }
1232 template<
typename... _Args>
1235 {
return _M_h.emplace(std::forward<_Args>(__args)...); }
1254 template<
typename... _Args>
1257 {
return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
1269 {
return _M_h.insert(__x); }
1294 insert(const_iterator __hint,
const value_type& __x)
1295 {
return _M_h.insert(__hint, __x); }
1298 insert(const_iterator __hint, value_type&& __x)
1299 {
return _M_h.insert(__hint,
std::move(__x)); }
1310 template<
typename _InputIterator>
1312 insert(_InputIterator __first, _InputIterator __last)
1313 { _M_h.insert(__first, __last); }
1324 { _M_h.insert(__l); }
1326 #if __cplusplus > 201402L
1331 __glibcxx_assert(__pos !=
end());
1332 return _M_h.extract(__pos);
1338 {
return _M_h.extract(__key); }
1347 insert(const_iterator __hint, node_type&& __nh)
1368 {
return _M_h.erase(__position); }
1373 {
return _M_h.erase(__position); }
1391 {
return _M_h.erase(__x); }
1410 erase(const_iterator __first, const_iterator __last)
1411 {
return _M_h.erase(__first, __last); }
1435 noexcept( noexcept(_M_h.swap(__x._M_h)) )
1436 { _M_h.swap(__x._M_h); }
1438 #if __cplusplus > 201402L
1439 template<
typename,
typename,
typename>
1440 friend class std::_Hash_merge_helper;
1442 template<
typename _H2,
typename _P2>
1447 = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
1451 template<
typename _H2,
typename _P2>
1453 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source)
1454 { merge(__source); }
1456 template<
typename _H2,
typename _P2>
1458 merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source)
1461 = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
1465 template<
typename _H2,
typename _P2>
1467 merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source)
1468 { merge(__source); }
1477 {
return _M_h.hash_function(); }
1483 {
return _M_h.key_eq(); }
1501 {
return _M_h.find(__x); }
1503 #if __cplusplus > 201703L
1504 template<
typename _Kt>
1506 find(
const _Kt& __x)
1507 -> decltype(_M_h._M_find_tr(__x))
1508 {
return _M_h._M_find_tr(__x); }
1513 {
return _M_h.find(__x); }
1515 #if __cplusplus > 201703L
1516 template<
typename _Kt>
1518 find(
const _Kt& __x)
const
1519 -> decltype(_M_h._M_find_tr(__x))
1520 {
return _M_h._M_find_tr(__x); }
1532 {
return _M_h.count(__x); }
1534 #if __cplusplus > 201703L
1535 template<
typename _Kt>
1537 count(
const _Kt& __x)
const -> decltype(_M_h._M_count_tr(__x))
1538 {
return _M_h._M_count_tr(__x); }
1542 #if __cplusplus > 201703L
1550 contains(
const key_type& __x)
const
1551 {
return _M_h.find(__x) != _M_h.end(); }
1553 template<
typename _Kt>
1555 contains(
const _Kt& __x)
const
1556 -> decltype(_M_h._M_find_tr(__x),
void(),
true)
1557 {
return _M_h._M_find_tr(__x) != _M_h.end(); }
1570 {
return _M_h.equal_range(__x); }
1572 #if __cplusplus > 201703L
1573 template<
typename _Kt>
1576 -> decltype(_M_h._M_equal_range_tr(__x))
1577 {
return _M_h._M_equal_range_tr(__x); }
1582 {
return _M_h.equal_range(__x); }
1584 #if __cplusplus > 201703L
1585 template<
typename _Kt>
1588 -> decltype(_M_h._M_equal_range_tr(__x))
1589 {
return _M_h._M_equal_range_tr(__x); }
1598 {
return _M_h.bucket_count(); }
1603 {
return _M_h.max_bucket_count(); }
1611 bucket_size(size_type __n)
const
1612 {
return _M_h.bucket_size(__n); }
1620 bucket(
const key_type& __key)
const
1621 {
return _M_h.bucket(__key); }
1632 {
return _M_h.begin(__n); }
1634 const_local_iterator
1635 begin(size_type __n)
const
1636 {
return _M_h.begin(__n); }
1638 const_local_iterator
1639 cbegin(size_type __n)
const
1640 {
return _M_h.cbegin(__n); }
1652 {
return _M_h.end(__n); }
1654 const_local_iterator
1655 end(size_type __n)
const
1656 {
return _M_h.end(__n); }
1658 const_local_iterator
1659 cend(size_type __n)
const
1660 {
return _M_h.cend(__n); }
1668 {
return _M_h.load_factor(); }
1674 {
return _M_h.max_load_factor(); }
1682 { _M_h.max_load_factor(__z); }
1693 { _M_h.rehash(__n); }
1704 { _M_h.reserve(__n); }
1706 template<
typename _Value1,
typename _Hash1,
typename _Pred1,
1714 #if __cpp_deduction_guides >= 201606
1716 template<
typename _InputIterator,
1718 hash<typename iterator_traits<_InputIterator>::value_type>,
1720 equal_to<typename iterator_traits<_InputIterator>::value_type>,
1721 typename _Allocator =
1722 allocator<typename iterator_traits<_InputIterator>::value_type>,
1723 typename = _RequireInputIter<_InputIterator>,
1724 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1725 typename = _RequireNotAllocator<_Pred>,
1726 typename = _RequireAllocator<_Allocator>>
1727 unordered_multiset(_InputIterator, _InputIterator,
1728 unordered_multiset<int>::size_type = {},
1729 _Hash = _Hash(), _Pred = _Pred(),
1730 _Allocator = _Allocator())
1731 -> unordered_multiset<
typename iterator_traits<_InputIterator>::value_type,
1732 _Hash, _Pred, _Allocator>;
1734 template<
typename _Tp,
typename _Hash = hash<_Tp>,
1735 typename _Pred = equal_to<_Tp>,
1736 typename _Allocator = allocator<_Tp>,
1737 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1738 typename = _RequireNotAllocator<_Pred>,
1739 typename = _RequireAllocator<_Allocator>>
1740 unordered_multiset(initializer_list<_Tp>,
1741 unordered_multiset<int>::size_type = {},
1742 _Hash = _Hash(), _Pred = _Pred(),
1743 _Allocator = _Allocator())
1744 -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
1746 template<
typename _InputIterator,
typename _Allocator,
1747 typename = _RequireInputIter<_InputIterator>,
1748 typename = _RequireAllocator<_Allocator>>
1749 unordered_multiset(_InputIterator, _InputIterator,
1750 unordered_multiset<int>::size_type, _Allocator)
1751 -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
1753 iterator_traits<_InputIterator>::value_type>,
1755 iterator_traits<_InputIterator>::value_type>,
1758 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
1759 typename = _RequireInputIter<_InputIterator>,
1760 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1761 typename = _RequireAllocator<_Allocator>>
1762 unordered_multiset(_InputIterator, _InputIterator,
1763 unordered_multiset<int>::size_type,
1765 -> unordered_multiset<
typename
1766 iterator_traits<_InputIterator>::value_type,
1770 iterator_traits<_InputIterator>::value_type>,
1773 template<
typename _Tp,
typename _Allocator,
1774 typename = _RequireAllocator<_Allocator>>
1775 unordered_multiset(initializer_list<_Tp>,
1776 unordered_multiset<int>::size_type, _Allocator)
1777 -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
1779 template<
typename _Tp,
typename _Hash,
typename _Allocator,
1780 typename = _RequireNotAllocatorOrIntegral<_Hash>,
1781 typename = _RequireAllocator<_Allocator>>
1782 unordered_multiset(initializer_list<_Tp>,
1783 unordered_multiset<int>::size_type, _Hash, _Allocator)
1784 -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
1788 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1790 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1791 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1792 noexcept(noexcept(__x.swap(__y)))
1795 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1797 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1798 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1799 noexcept(noexcept(__x.swap(__y)))
1802 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1804 operator==(
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1805 const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1806 {
return __x._M_h._M_equal(__y._M_h); }
1808 #if __cpp_impl_three_way_comparison < 201907L
1809 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1811 operator!=(
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
1812 const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
1813 {
return !(__x == __y); }
1816 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1818 operator==(
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1819 const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1820 {
return __x._M_h._M_equal(__y._M_h); }
1822 #if __cpp_impl_three_way_comparison < 201907L
1823 template<
class _Value,
class _Hash,
class _Pred,
class _Alloc>
1825 operator!=(
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
1826 const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
1827 {
return !(__x == __y); }
1830 _GLIBCXX_END_NAMESPACE_CONTAINER
1832 #if __cplusplus > 201402L
1834 template<
typename _Val,
typename _Hash1,
typename _Eq1,
typename _Alloc,
1835 typename _Hash2,
typename _Eq2>
1836 struct _Hash_merge_helper<
1837 _GLIBCXX_STD_C::unordered_set<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2>
1840 template<
typename... _Tp>
1841 using unordered_set = _GLIBCXX_STD_C::unordered_set<_Tp...>;
1842 template<
typename... _Tp>
1843 using unordered_multiset = _GLIBCXX_STD_C::unordered_multiset<_Tp...>;
1845 friend unordered_set<_Val, _Hash1, _Eq1, _Alloc>;
1848 _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
1849 {
return __set._M_h; }
1852 _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
1853 {
return __set._M_h; }
1857 template<
typename _Val,
typename _Hash1,
typename _Eq1,
typename _Alloc,
1858 typename _Hash2,
typename _Eq2>
1859 struct _Hash_merge_helper<
1860 _GLIBCXX_STD_C::unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>,
1864 template<
typename... _Tp>
1865 using unordered_set = _GLIBCXX_STD_C::unordered_set<_Tp...>;
1866 template<
typename... _Tp>
1867 using unordered_multiset = _GLIBCXX_STD_C::unordered_multiset<_Tp...>;
1869 friend unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>;
1872 _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
1873 {
return __set._M_h; }
1876 _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
1877 {
return __set._M_h; }
1881 _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.