From: Tomasz Kamiński Date: Mon, 17 Mar 2025 13:30:35 +0000 (+0100) Subject: libstdc++: Add P1206R7 from_range members to unordered sets [PR111055] X-Git-Tag: basepoints/gcc-16~1299 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5f033bf16458e250e6b7cda8e27d0100197cba14;p=thirdparty%2Fgcc.git libstdc++: Add P1206R7 from_range members to unordered sets [PR111055] This is another piece of P1206R7, adding new members to std::unordered_set and std::unordered_multiset. PR libstdc++/111055 libstdc++-v3/ChangeLog: * include/bits/hashtable.h (_M_rehash_insert) (_M_insert_range_multi): Extracted rehashing for range insertion to separate function. * include/bits/unordered_set.h (unordered_set): Define from_range constructors and insert_range member. (unordered_multiset) Likewise. * testsuite/23_containers/unordered_multiset/cons/from_range.cc: New test. * testsuite/23_containers/unordered_multiset/modifiers/insert_range.cc: New test. * testsuite/23_containers/unordered_set/cons/from_range.cc: New test. * testsuite/23_containers/unordered_set/modifiers/insert_range.cc: New test. Reviewed-by: Jonathan Wakely Signed-off-by: Tomasz Kamiński --- diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 246e62afc6af..20f9bd98d5b7 100644 --- a/libstdc++-v3/include/bits/hashtable.h +++ b/libstdc++-v3/include/bits/hashtable.h @@ -798,6 +798,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_equal_range_tr(const _Kt& __k) const; #endif // __glibcxx_generic_unordered_lookup + void _M_rehash_insert(size_type __n); + private: // Bucket index computation helpers. size_type @@ -2388,6 +2390,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __pos; } + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash_insert(size_type __n) + { + using __pair_type = std::pair; + if (__n == 0) + return; + + __rehash_guard_t __rehash_guard(_M_rehash_policy); + __pair_type __do_rehash + = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n); + + if (__do_rehash.first) + _M_rehash(__do_rehash.second, false_type{}); + + __rehash_guard._M_guarded_obj = nullptr; + } + + template:: _M_insert_range_multi(_InputIterator __first, _InputIterator __last) { - using __pair_type = std::pair; - - size_type __n_elt = __detail::__distance_fw(__first, __last); - if (__n_elt == 0) - return; - - __rehash_guard_t __rehash_guard(_M_rehash_policy); - __pair_type __do_rehash - = _M_rehash_policy._M_need_rehash(_M_bucket_count, - _M_element_count, - __n_elt); - - if (__do_rehash.first) - _M_rehash(__do_rehash.second, false_type{}); - - __rehash_guard._M_guarded_obj = nullptr; + _M_rehash_insert(__detail::__distance_fw(__first, __last)); for (; __first != __last; ++__first) _M_emplace_multi(cend(), *__first); } diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h index fc9d584c0365..21ffdaf50a02 100644 --- a/libstdc++-v3/include/bits/unordered_set.h +++ b/libstdc++-v3/include/bits/unordered_set.h @@ -34,6 +34,9 @@ #include #include // hash #include // equal_to +#if __glibcxx_ranges_to_container // C++ >= 23 +# include // ranges::begin, ranges::distance etc. +#endif namespace std _GLIBCXX_VISIBILITY(default) { @@ -268,6 +271,42 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER : unordered_set(__l, __n, __hf, key_equal(), __a) { } +#if __glibcxx_ranges_to_container // C++ >= 23 + /** + * @brief Builds an %unordered_set from a range. + * @since C++23 + * @param __rg An input range of elements that can be converted to + * the set's value type. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_set consisting of copies of the elements in the + * range. This is linear in N (where N is `std::ranges::size(__rg)`). + */ + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_set(from_range_t, _Rg&& __rg, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { insert_range(std::forward<_Rg>(__rg)); } + + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_set(from_range_t, _Rg&& __rg, size_type __n, + const allocator_type& __a) + : _M_h(__n, hasher(), key_equal(), __a) + { insert_range(std::forward<_Rg>(__rg)); } + + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_set(from_range_t, _Rg&& __rg, size_type __n, + const hasher& __hf, const allocator_type& __a) + : _M_h(__n, __hf, key_equal(), __a) + { insert_range(std::forward<_Rg>(__rg)); } +#endif + /// Copy assignment operator. unordered_set& operator=(const unordered_set&) = default; @@ -487,6 +526,24 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER insert(initializer_list __l) { _M_h.insert(__l); } +#if __glibcxx_ranges_to_container // C++ >= 23 + /** + * @brief Inserts a range of elements. + * @since C++23 + * @param __rg An input range of elements that can be converted to + * the set's value type. + */ + template<__detail::__container_compatible_range<_Value> _Rg> + void + insert_range(_Rg&& __rg) + { + auto __first = ranges::begin(__rg); + const auto __last = ranges::end(__rg); + for (; __first != __last; ++__first) + _M_h.emplace(*__first); + } +#endif + #ifdef __glibcxx_node_extract // >= C++17 && HOSTED /// Extract a node. node_type @@ -949,6 +1006,41 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER unordered_set::size_type, _Hash, _Allocator) -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>; +#if __glibcxx_ranges_to_container // C++ >= 23 + template>, + __not_allocator_like _Pred = equal_to>, + __allocator_like _Allocator = allocator>> + unordered_set(from_range_t, _Rg&&, unordered_set::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) + -> unordered_set, _Hash, _Pred, _Allocator>; + + template + unordered_set(from_range_t, _Rg&&, unordered_set::size_type, + _Allocator) + -> unordered_set, + hash>, + equal_to>, + _Allocator>; + + template + unordered_set(from_range_t, _Rg&&, _Allocator) + -> unordered_set, + hash>, + equal_to>, + _Allocator>; + + template + unordered_set(from_range_t, _Rg&&, unordered_set::size_type, + _Hash, _Allocator) + -> unordered_set, _Hash, + equal_to>, + _Allocator>; +#endif #endif /** @@ -1150,6 +1242,43 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER : unordered_multiset(__l, __n, __hf, key_equal(), __a) { } +#if __glibcxx_ranges_to_container // C++ >= 23 + /** + * @brief Builds an %unordered_multiset from a range. + * @since C++23 + * @param __rg An input range of elements that can be converted to + * the set's value type. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_multiset consisting of copies of the elements in the + * range. This is linear in N (where N is `std::ranges::size(__rg)`). + */ + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_multiset(from_range_t, _Rg&& __rg, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { insert_range(std::forward<_Rg>(__rg)); } + + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_multiset(from_range_t, _Rg&& __rg, size_type __n, + const allocator_type& __a) + : _M_h(__n, hasher(), key_equal(), __a) + { insert_range(std::forward<_Rg>(__rg)); } + + template<__detail::__container_compatible_range<_Value> _Rg> + unordered_multiset(from_range_t, _Rg&& __rg, size_type __n, + const hasher& __hf, const allocator_type& __a) + : _M_h(__n, __hf, key_equal(), __a) + { insert_range(std::forward<_Rg>(__rg)); } +#endif + + /** * @brief %Unordered_multiset list assignment operator. * @param __l An initializer_list. @@ -1339,6 +1468,32 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER insert(initializer_list __l) { _M_h.insert(__l); } +#if __glibcxx_ranges_to_container // C++ >= 23 + /** + * @brief Inserts a range of elements. + * @since C++23 + * @param __rg An input range of elements that can be converted to + * the set's value type. + */ + template<__detail::__container_compatible_range<_Value> _Rg> + void + insert_range(_Rg&& __rg) + { + auto __first = ranges::begin(__rg); + const auto __last = ranges::end(__rg); + if (__first == __last) + return; + + if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>) + _M_h._M_rehash_insert(ranges::distance(__rg)); + else + _M_h._M_rehash_insert(1); + + for (; __first != __last; ++__first) + _M_h.emplace(*__first); + } +#endif + #ifdef __glibcxx_node_extract // >= C++17 && HOSTED /// Extract a node. node_type @@ -1807,6 +1962,44 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER unordered_multiset::size_type, _Hash, _Allocator) -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>; +#if __glibcxx_ranges_to_container // C++ >= 23 + template>, + __not_allocator_like _Pred = equal_to>, + __allocator_like _Allocator = allocator>> + unordered_multiset(from_range_t, _Rg&&, + unordered_multiset::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), + _Allocator = _Allocator()) + -> unordered_multiset, _Hash, _Pred, _Allocator>; + + template + unordered_multiset(from_range_t, _Rg&&, _Allocator) + -> unordered_multiset, + hash>, + equal_to>, + _Allocator>; + + template + unordered_multiset(from_range_t, _Rg&&, unordered_multiset::size_type, + _Allocator) + -> unordered_multiset, + hash>, + equal_to>, + _Allocator>; + + template + unordered_multiset(from_range_t, _Rg&&, + unordered_multiset::size_type, + _Hash, _Allocator) + -> unordered_multiset, _Hash, + equal_to>, + _Allocator>; +#endif #endif template diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/from_range.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/from_range.cc new file mode 100644 index 000000000000..fb3887644233 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/from_range.cc @@ -0,0 +1,201 @@ +// { dg-do run { target c++23 } } + +#include +#include +#include +#include +#include +#include + +struct StateHash { + int state = 17; + + template + size_t operator()(T const& t) const { + return std::hash()(t) + 43; + } +}; + +struct StateEq { + int state = 7; + + template + bool operator()(T const& l, U const & r) const { + return l == r; + } +}; + +void +test_deduction_guide(long* p) +{ + __gnu_test::test_input_range r(p, p); + std::unordered_multiset s(std::from_range, r); + static_assert(std::is_same_v>); + + std::unordered_multiset s2(std::from_range, r, 0); + static_assert(std::is_same_v>); + + StateHash hf; + std::unordered_multiset s3(std::from_range, r, 0, hf); + static_assert(std::is_same_v< + decltype(s3), + std::unordered_multiset>); + + StateEq eq; + std::unordered_multiset s4(std::from_range, r, 0, hf, eq); + static_assert(std::is_same_v< + decltype(s4), + std::unordered_multiset>); + + using Alloc = __gnu_test::SimpleAllocator; + Alloc alloc; + // LWG2713: there is no matching constructor + // std::unordered_multiset s5(std::from_range, r, alloc); + // static_assert(std::is_same_v< + // decltype(s5), + // std::unordered_multiset, std::equal_to, Alloc>>); + + std::unordered_multiset s6(std::from_range, r, 0, alloc); + static_assert(std::is_same_v< + decltype(s6), + std::unordered_multiset, std::equal_to, Alloc>>); + + std::unordered_multiset s7(std::from_range, r, 0, hf, alloc); + static_assert(std::is_same_v< + decltype(s7), + std::unordered_multiset, Alloc>>); + + std::unordered_multiset s8(std::from_range, r, 0, hf, eq, alloc); + static_assert(std::is_same_v< + decltype(s8), + std::unordered_multiset>); +} + +template +constexpr bool is_equal(std::hash, std::hash) +{ return true; } + +template +constexpr bool is_equal(std::equal_to, std::equal_to) +{ return true; } + +constexpr bool is_equal(StateHash lhs, StateHash rhs) +{ return lhs.state = rhs.state; } + + +constexpr bool is_equal(StateEq lhs, StateEq rhs) +{ return lhs.state = rhs.state; } + +template +constexpr void +do_test(Alloc alloc, Hash hf, Equal eqf) +{ + // The unordered_multiset's value_typ. + using V = typename Alloc::value_type; + + // The range's value_type. + using T = std::ranges::range_value_t; + T a[]{1,2,3,4,5,6,7,8,9,1,2,3,4,5}; + + auto eq = [&](std::unordered_multiset const& l, + std::span r) { + if (l.size() != r.size()) + return false; + + return std::ranges::is_permutation(l, r, eqf); + }; + + std::unordered_multiset + s0(std::from_range, Range(a, a+0)); + VERIFY( s0.empty() ); + VERIFY( is_equal(s0.hash_function(), Hash()) ); + VERIFY( is_equal(s0.key_eq(), Equal()) ); + VERIFY( s0.get_allocator() == Alloc() ); + + std::unordered_multiset + s4(std::from_range, Range(a, a+4), 2); + VERIFY( eq(s4, {a, 4}) ); + VERIFY( s4.bucket_count() >= 2 ); + VERIFY( is_equal(s4.hash_function(), Hash()) ); + VERIFY( is_equal(s4.key_eq(), Equal()) ); + VERIFY( s4.get_allocator() == Alloc() ); + + std::unordered_multiset + s7(std::from_range, Range(a, a+7), 3, hf); + VERIFY( eq(s7, {a, 7}) ); + VERIFY( s7.bucket_count() >= 3 ); + VERIFY( is_equal(s7.hash_function(), hf) ); + VERIFY( is_equal(s7.key_eq(), Equal()) ); + VERIFY( s7.get_allocator() == Alloc() ); + + std::unordered_multiset + s9(std::from_range, Range(a, a+9), 5, hf, eqf); + VERIFY( eq(s9, {a, 9}) ); + VERIFY( s9.bucket_count() >= 5 ); + VERIFY( s9.get_allocator() == Alloc() ); + VERIFY( is_equal(s9.hash_function(), hf) ); + VERIFY( is_equal(s9.key_eq(), eqf) ); + + // LWG2713: there is no matching constructor + // std::unordered_multiset + // sa(std::from_range, Range(a, a+14), alloc); + // VERIFY( eq(sa1, {a, 14}) ); + // VERIFY( is_equal(sa1.hash_function(), Hash()) ); + // VERIFY( is_equal(sa1.key_eq(), Equal()) ); + // VERIFY( sa1.get_allocator() == alloc ); + + std::unordered_multiset + sa2(std::from_range, Range(a, a+14), 2, alloc); + VERIFY( eq(sa2, {a, 14}) ); + VERIFY( sa2.bucket_count() >= 2 ); + VERIFY( is_equal(sa2.hash_function(), Hash()) ); + VERIFY( is_equal(sa2.key_eq(), Equal()) ); + VERIFY( sa2.get_allocator() == alloc ); + + std::unordered_multiset + sa3(std::from_range, Range(a, a+14), 3, hf, alloc); + VERIFY( eq(sa3, {a, 14}) ); + VERIFY( sa3.bucket_count() >= 3 ); + VERIFY( is_equal(sa3.hash_function(), hf) ); + VERIFY( is_equal(sa3.key_eq(), Equal()) ); + VERIFY( sa3.get_allocator() == alloc ); + + std::unordered_multiset + sa4(std::from_range, Range(a, a+14), 5, hf, eqf, alloc); + VERIFY( eq(sa4, {a, 14}) ); + VERIFY( sa4.bucket_count() >= 5 ); + VERIFY( is_equal(sa4.hash_function(), hf) ); + VERIFY( is_equal(sa4.key_eq(), eqf) ); + VERIFY( sa4.get_allocator() == alloc ); +} + +template +void +do_test_ahe() +{ + do_test(std::allocator(), + std::hash(), std::equal_to()); + do_test(std::allocator(), + StateHash{27}, StateEq{17}); + do_test(__gnu_test::uneq_allocator(42), + std::hash(), std::equal_to()); + do_test(__gnu_test::uneq_allocator(42), + StateHash{27}, StateEq{17}); +} + +bool +test_ranges() +{ + using namespace __gnu_test; + + do_test_ahe>(); + do_test_ahe>(); + do_test_ahe>(); + + return true; +} + +int main() +{ + test_ranges(); +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/modifiers/insert_range.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/modifiers/insert_range.cc new file mode 100644 index 000000000000..efb66bd5772d --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/modifiers/insert_range.cc @@ -0,0 +1,62 @@ +// { dg-do run { target c++23 } } + +#include +#include +#include +#include +#include +#include + +template +constexpr void +do_test() +{ + // The range's value_type. + using T = std::ranges::range_value_t; + T a[]{1,2,3,4,5,6,7,8,9,1,2,3,4,5}; + + auto eq = [&](std::unordered_multiset const& l, + std::span r) { + if (l.size() != r.size()) + return false; + + return std::ranges::is_permutation(l, r); + }; + + std::unordered_multiset s; + s.insert_range(Range(a, a+0)); + VERIFY( s.empty() ); + + s.insert_range(Range(a, a+4)); + VERIFY( eq(s, {a, 4}) ); + + s.insert_range(Range(a+4, a+9)); + VERIFY( eq(s, {a, 9}) ); + + s.insert_range(Range(a+9, a+14)); + VERIFY( eq(s, {a, 14}) ); +} + +template +void +do_test_v() +{ + do_test(); +} + +bool +test_ranges() +{ + using namespace __gnu_test; + + do_test_v>(); + do_test_v>(); + do_test_v>(); + + return true; +} + +int main() +{ + test_ranges(); +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/from_range.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/from_range.cc new file mode 100644 index 000000000000..c1acf1436610 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/from_range.cc @@ -0,0 +1,201 @@ +// { dg-do run { target c++23 } } + +#include +#include +#include +#include +#include +#include + +struct StateHash { + int state = 17; + + template + size_t operator()(T const& t) const { + return std::hash()(t) + 43; + } +}; + +struct StateEq { + int state = 7; + + template + bool operator()(T const& l, U const & r) const { + return l == r; + } +}; + +void +test_deduction_guide(long* p) +{ + __gnu_test::test_input_range r(p, p); + std::unordered_set s(std::from_range, r); + static_assert(std::is_same_v>); + + std::unordered_set s2(std::from_range, r, 0); + static_assert(std::is_same_v>); + + StateHash hf; + std::unordered_set s3(std::from_range, r, 0, hf); + static_assert(std::is_same_v< + decltype(s3), + std::unordered_set>); + + StateEq eq; + std::unordered_set s4(std::from_range, r, 0, hf, eq); + static_assert(std::is_same_v< + decltype(s4), + std::unordered_set>); + + using Alloc = __gnu_test::SimpleAllocator; + Alloc alloc; + // LWG2713: there is no matching constructor + // std::unordered_set s5(std::from_range, r, alloc); + // static_assert(std::is_same_v< + // decltype(s5), + // std::unordered_set, std::equal_to, Alloc>>); + + std::unordered_set s6(std::from_range, r, 0, alloc); + static_assert(std::is_same_v< + decltype(s6), + std::unordered_set, std::equal_to, Alloc>>); + + std::unordered_set s7(std::from_range, r, 0, hf, alloc); + static_assert(std::is_same_v< + decltype(s7), + std::unordered_set, Alloc>>); + + std::unordered_set s8(std::from_range, r, 0, hf, eq, alloc); + static_assert(std::is_same_v< + decltype(s8), + std::unordered_set>); +} + +template +constexpr bool is_equal(std::hash, std::hash) +{ return true; } + +template +constexpr bool is_equal(std::equal_to, std::equal_to) +{ return true; } + +constexpr bool is_equal(StateHash lhs, StateHash rhs) +{ return lhs.state = rhs.state; } + + +constexpr bool is_equal(StateEq lhs, StateEq rhs) +{ return lhs.state = rhs.state; } + +template +constexpr void +do_test(Alloc alloc, Hash hf, Equal eqf) +{ + // The unordered_set's value_typ. + using V = typename Alloc::value_type; + + // The range's value_type. + using T = std::ranges::range_value_t; + T a[]{1,2,3,4,5,6,7,8,9,1,2,3,4,5}; + + auto eq = [&](std::unordered_set const& l, + std::span r) { + if (l.size() != r.size()) + return false; + + return std::ranges::is_permutation(l, r, eqf); + }; + + std::unordered_set + s0(std::from_range, Range(a, a+0)); + VERIFY( s0.empty() ); + VERIFY( is_equal(s0.hash_function(), Hash()) ); + VERIFY( is_equal(s0.key_eq(), Equal()) ); + VERIFY( s0.get_allocator() == Alloc() ); + + std::unordered_set + s4(std::from_range, Range(a, a+4), 2); + VERIFY( eq(s4, {a, 4}) ); + VERIFY( s4.bucket_count() >= 2 ); + VERIFY( is_equal(s4.hash_function(), Hash()) ); + VERIFY( is_equal(s4.key_eq(), Equal()) ); + VERIFY( s4.get_allocator() == Alloc() ); + + std::unordered_set + s7(std::from_range, Range(a, a+7), 3, hf); + VERIFY( eq(s7, {a, 7}) ); + VERIFY( s7.bucket_count() >= 3 ); + VERIFY( is_equal(s7.hash_function(), hf) ); + VERIFY( is_equal(s7.key_eq(), Equal()) ); + VERIFY( s7.get_allocator() == Alloc() ); + + std::unordered_set + s9(std::from_range, Range(a, a+9), 5, hf, eqf); + VERIFY( eq(s9, {a, 9}) ); + VERIFY( s9.bucket_count() >= 5 ); + VERIFY( s9.get_allocator() == Alloc() ); + VERIFY( is_equal(s9.hash_function(), hf) ); + VERIFY( is_equal(s9.key_eq(), eqf) ); + + // LWG2713: there is no matching constructor + // std::unordered_set + // sa(std::from_range, Range(a, a+14), alloc); + // VERIFY( eq(sa1, {a, 9}) ); + // VERIFY( is_equal(sa1.hash_function(), Hash()) ); + // VERIFY( is_equal(sa1.key_eq(), Equal()) ); + // VERIFY( sa1.get_allocator() == alloc ); + + std::unordered_set + sa2(std::from_range, Range(a, a+14), 2, alloc); + VERIFY( eq(sa2, {a, 9}) ); + VERIFY( sa2.bucket_count() >= 2 ); + VERIFY( is_equal(sa2.hash_function(), Hash()) ); + VERIFY( is_equal(sa2.key_eq(), Equal()) ); + VERIFY( sa2.get_allocator() == alloc ); + + std::unordered_set + sa3(std::from_range, Range(a, a+14), 3, hf, alloc); + VERIFY( eq(sa3, {a, 9}) ); + VERIFY( sa3.bucket_count() >= 3 ); + VERIFY( is_equal(sa3.hash_function(), hf) ); + VERIFY( is_equal(sa3.key_eq(), Equal()) ); + VERIFY( sa3.get_allocator() == alloc ); + + std::unordered_set + sa4(std::from_range, Range(a, a+14), 5, hf, eqf, alloc); + VERIFY( eq(sa4, {a, 9}) ); + VERIFY( sa4.bucket_count() >= 5 ); + VERIFY( is_equal(sa4.hash_function(), hf) ); + VERIFY( is_equal(sa4.key_eq(), eqf) ); + VERIFY( sa4.get_allocator() == alloc ); +} + +template +void +do_test_ahe() +{ + do_test(std::allocator(), + std::hash(), std::equal_to()); + do_test(std::allocator(), + StateHash{27}, StateEq{17}); + do_test(__gnu_test::uneq_allocator(42), + std::hash(), std::equal_to()); + do_test(__gnu_test::uneq_allocator(42), + StateHash{27}, StateEq{17}); +} + +bool +test_ranges() +{ + using namespace __gnu_test; + + do_test_ahe>(); + do_test_ahe>(); + do_test_ahe>(); + + return true; +} + +int main() +{ + test_ranges(); +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/modifiers/insert_range.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/modifiers/insert_range.cc new file mode 100644 index 000000000000..9c74ac5f9b4d --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/modifiers/insert_range.cc @@ -0,0 +1,65 @@ +// { dg-do run { target c++23 } } + +#include +#include +#include +#include +#include +#include + +template +constexpr void +do_test() +{ + // The range's value_type. + using T = std::ranges::range_value_t; + T a[]{1,2,3,4,5,6,7,8,9,1,2,3,4,5}; + + auto eq = [&](std::unordered_set const& l, + std::span r) { + if (l.size() != r.size()) + return false; + + return std::ranges::is_permutation(l, r); + }; + + std::unordered_set s; + s.insert_range(Range(a, a+0)); + VERIFY( s.empty() ); + + s.insert_range(Range(a, a+4)); + VERIFY( eq(s, {a, 4}) ); + + s.insert_range(Range(a+4, a+7)); + VERIFY( eq(s, {a, 7}) ); + + s.insert_range(Range(a, a+9)); + VERIFY( eq(s, {a, 9}) ); + + s.insert_range(Range(a, a+14)); + VERIFY( eq(s, {a, 9}) ); +} + +template +void +do_test_v() +{ + do_test(); +} + +bool +test_ranges() +{ + using namespace __gnu_test; + + do_test_v>(); + do_test_v>(); + do_test_v>(); + + return true; +} + +int main() +{ + test_ranges(); +}