[libc++] implement std::flat_set #125241
Merged
[libc++] implement std::flat_set #125241
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
huixie90
force-pushed
the
hxie/flat_set
branch
from
98938db to
a0f80fc
Compare
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
ldionne
requested changes
Jan 31, 2025
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp
Outdated
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default.pass.cpp
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp
Outdated
Show resolved
Hide resolved
huixie90
force-pushed
the
hxie/flat_set
branch
from
2e2adaf to
6114724
Compare
llvmbot
added
the
libc++
|
@llvm/pr-subscribers-libcxx Author: Hui (huixie90) ChangesPatch is 336.17 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/125241.diff 91 Files Affected:
diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst
index 82f1de6bad39423..0c1029f50a6fe7d 100644
--- a/libcxx/docs/ReleaseNotes/21.rst
+++ b/libcxx/docs/ReleaseNotes/21.rst
@@ -39,6 +39,7 @@ Implemented Papers
------------------
- N4258: Cleaning-up noexcept in the Library (`Github <https://github.com/llvm/llvm-project/issues/99937>`__)
+- P1222R4: A Standard ``flat_set`` is partially implemented and ``flat_set`` is provided (`Github <https://github.com/llvm/llvm-project/issues/105193>`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index 264c5417a5c28be..bcd9c5c43a9c695 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -54,7 +54,7 @@
"`P0009R18 <https://wg21.link/P0009R18>`__","mdspan: A Non-Owning Multidimensional Array Reference","2022-07 (Virtual)","|Complete|","18",""
"`P0429R9 <https://wg21.link/P0429R9>`__","A Standard ``flat_map``","2022-07 (Virtual)","|Complete|","20",""
"`P1169R4 <https://wg21.link/P1169R4>`__","``static operator()``","2022-07 (Virtual)","|Complete|","16",""
-"`P1222R4 <https://wg21.link/P1222R4>`__","A Standard ``flat_set``","2022-07 (Virtual)","","",""
+"`P1222R4 <https://wg21.link/P1222R4>`__","A Standard ``flat_set``","2022-07 (Virtual)","|In progress|","",""
"`P1223R5 <https://wg21.link/P1223R5>`__","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","2022-07 (Virtual)","|Complete|","19",""
"`P1467R9 <https://wg21.link/P1467R9>`__","Extended ``floating-point`` types and standard names","2022-07 (Virtual)","","",""
"`P1642R11 <https://wg21.link/P1642R11>`__","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","2022-07 (Virtual)","","",""
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 8dac823503d73f5..75acf9f7899ff66 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -367,6 +367,7 @@ set(files
__flat_map/sorted_equivalent.h
__flat_map/sorted_unique.h
__flat_map/utils.h
+ __flat_set/flat_set.h
__format/buffer.h
__format/concepts.h
__format/container_adaptor.h
@@ -986,6 +987,7 @@ set(files
fenv.h
filesystem
flat_map
+ flat_set
float.h
format
forward_list
diff --git a/libcxx/include/__flat_set/flat_set.h b/libcxx/include/__flat_set/flat_set.h
new file mode 100644
index 000000000000000..30fe1343e63ee9d
--- /dev/null
+++ b/libcxx/include/__flat_set/flat_set.h
@@ -0,0 +1,856 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FLAT_SET_FLAT_SET_H
+#define _LIBCPP___FLAT_SET_FLAT_SET_H
+
+#include <__algorithm/lexicographical_compare_three_way.h>
+#include <__algorithm/min.h>
+#include <__algorithm/ranges_adjacent_find.h>
+#include <__algorithm/ranges_equal.h>
+#include <__algorithm/ranges_inplace_merge.h>
+#include <__algorithm/ranges_lower_bound.h>
+#include <__algorithm/ranges_partition_point.h>
+#include <__algorithm/ranges_sort.h>
+#include <__algorithm/ranges_unique.h>
+#include <__algorithm/ranges_upper_bound.h>
+#include <__algorithm/remove_if.h>
+#include <__assert>
+#include <__compare/synth_three_way.h>
+#include <__concepts/swappable.h>
+#include <__config>
+#include <__cstddef/byte.h>
+#include <__cstddef/ptrdiff_t.h>
+#include <__flat_map/sorted_unique.h>
+#include <__functional/invoke.h>
+#include <__functional/is_transparent.h>
+#include <__functional/operations.h>
+#include <__fwd/vector.h>
+#include <__iterator/concepts.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__iterator/ranges_iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/uses_allocator.h>
+#include <__memory/uses_allocator_construction.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/drop_view.h>
+#include <__ranges/from_range.h>
+#include <__ranges/ref_view.h>
+#include <__ranges/size.h>
+#include <__ranges/subrange.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/container_traits.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_same.h>
+#include <__utility/exception_guard.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/scope_guard.h>
+#include <__vector/vector.h>
+#include <initializer_list>
+#include <stdexcept>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Key, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>>
+class flat_set {
+ template <class, class, class>
+ friend class flat_set;
+
+ static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
+ static_assert(!is_same_v<_KeyContainer, std::vector<bool>>, "vector<bool> is not a sequence container");
+
+public:
+ // types
+ using key_type = _Key;
+ using value_type = _Key;
+ using key_compare = __type_identity_t<_Compare>;
+ using value_compare = _Compare;
+ using reference = value_type&;
+ using const_reference = const value_type&;
+ using size_type = typename _KeyContainer::size_type;
+ using difference_type = typename _KeyContainer::difference_type;
+ using iterator = typename _KeyContainer::const_iterator;
+ using const_iterator = iterator;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using container_type = _KeyContainer;
+
+public:
+ // [flat.set.cons], construct/copy/destroy
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set() noexcept(is_nothrow_default_constructible_v<_KeyContainer> && is_nothrow_default_constructible_v<_Compare>)
+ : __keys_(), __compare_() {}
+
+ _LIBCPP_HIDE_FROM_ABI flat_set(const flat_set&) = default;
+
+ _LIBCPP_HIDE_FROM_ABI flat_set(flat_set&& __other) noexcept(
+ is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_Compare>)
+# if _LIBCPP_HAS_EXCEPTIONS
+ try
+# endif // _LIBCPP_HAS_EXCEPTIONS
+ : __keys_(std::move(__other.__keys_)), __compare_(std::move(__other.__compare_)) {
+ __other.clear();
+# if _LIBCPP_HAS_EXCEPTIONS
+ } catch (...) {
+ __other.clear();
+ // gcc does not like the `throw` keyword in a conditionally noexcept function
+ if constexpr (!(is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_Compare>)) {
+ throw;
+ }
+# endif // _LIBCPP_HAS_EXCEPTIONS
+ }
+
+ _LIBCPP_HIDE_FROM_ABI explicit flat_set(const key_compare& __comp) : __keys_(), __compare_(__comp) {}
+
+ _LIBCPP_HIDE_FROM_ABI explicit flat_set(container_type __keys, const key_compare& __comp = key_compare())
+ : __keys_(std::move(__keys)), __compare_(__comp) {
+ __sort_and_unique();
+ }
+
+ _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, container_type __keys, const key_compare& __comp = key_compare())
+ : __keys_(std::move(__keys)), __compare_(__comp) {
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates");
+ }
+
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
+ : __keys_(), __compare_(__comp) {
+ insert(__first, __last);
+ }
+
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
+ : __keys_(__first, __last), __compare_(__comp) {
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates");
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range>
+ _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg)
+ : flat_set(from_range, std::forward<_Range>(__rg), key_compare()) {}
+
+ template <_ContainerCompatibleRange<value_type> _Range>
+ _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_set(__comp) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI flat_set(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+ : flat_set(__il.begin(), __il.end(), __comp) {}
+
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+ : flat_set(sorted_unique, __il.begin(), __il.end(), __comp) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI explicit flat_set(const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(const container_type& __keys, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, __keys) {
+ __sort_and_unique();
+ }
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, __keys, __comp) {
+ __sort_and_unique();
+ }
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, const container_type& __keys, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, __keys) {
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates");
+ }
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t, const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, __keys, __comp) {
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates");
+ }
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(const flat_set& __other, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, __other.__keys_, __other.__compare_) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(flat_set&& __other, const _Allocator& __alloc)
+# if _LIBCPP_HAS_EXCEPTIONS
+ try
+# endif // _LIBCPP_HAS_EXCEPTIONS
+ : flat_set(__ctor_uses_allocator_tag{}, __alloc, std::move(__other.__keys_), std::move(__other.__compare_)) {
+ __other.clear();
+# if _LIBCPP_HAS_EXCEPTIONS
+ } catch (...) {
+ __other.clear();
+ throw;
+# endif // _LIBCPP_HAS_EXCEPTIONS
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
+ _LIBCPP_HIDE_FROM_ABI flat_set(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert(__first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert(__first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert(sorted_unique, __first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t,
+ _InputIterator __first,
+ _InputIterator __last,
+ const key_compare& __comp,
+ const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert(sorted_unique, __first, __last);
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(initializer_list<value_type> __il, const _Allocator& __alloc)
+ : flat_set(__il.begin(), __il.end(), __alloc) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(__il.begin(), __il.end(), __comp, __alloc) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, initializer_list<value_type> __il, const _Allocator& __alloc)
+ : flat_set(sorted_unique, __il.begin(), __il.end(), __alloc) {}
+
+ template <class _Allocator>
+ requires uses_allocator<container_type, _Allocator>::value
+ _LIBCPP_HIDE_FROM_ABI
+ flat_set(sorted_unique_t, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_set(sorted_unique, __il.begin(), __il.end(), __comp, __alloc) {}
+
+ _LIBCPP_HIDE_FROM_ABI flat_set& operator=(initializer_list<value_type> __il) {
+ clear();
+ insert(__il);
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI flat_set& operator=(const flat_set&) = default;
+
+ _LIBCPP_HIDE_FROM_ABI flat_set& operator=(flat_set&& __other) noexcept(
+ is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_Compare>) {
+ // No matter what happens, we always want to clear the other container before returning
+ // since we moved from it
+ auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; });
+ {
+ // If an exception is thrown, we have no choice but to clear *this to preserve invariants
+ auto __on_exception = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ __keys_ = std::move(__other.__keys_);
+ __compare_ = std::move(__other.__compare_);
+ __on_exception.__complete();
+ }
+ return *this;
+ }
+
+ // iterators
+ _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept { return __keys_.begin(); }
+ _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return __keys_.begin(); }
+ _LIBCPP_HIDE_FROM_ABI iterator end() noexcept { return __keys_.end(); }
+ _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return __keys_.end(); }
+
+ _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+ _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+ _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+ _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return begin(); }
+ _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return end(); }
+ _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+ _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+
+ // [flat.set.capacity], capacity
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __keys_.empty(); }
+
+ _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __keys_.size(); }
+
+ _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept { return __keys_.max_size(); }
+
+ // [flat.set.modifiers], modifiers
+ template <class... _Args>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+ if constexpr (sizeof...(__args) == 1 && (is_same_v<remove_cvref_t<_Args>, _Key> && ...)) {
+ return __try_emplace(std::forward<_Args>(__args)...);
+ } else {
+ return __try_emplace(_Key(std::forward<_Args>(__args)...));
+ }
+ }
+
+ template <class... _Args>
+ _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
+ if constexpr (sizeof...(__args) == 1 && (is_same_v<remove_cvref_t<_Args>, _Key> && ...)) {
+ return __emplace_hint(std::move(__hint), std::forward<_Args>(__args)...);
+ } else {
+ return __emplace_hint(std::move(__hint), _Key(std::forward<_Args>(__args)...));
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return emplace(__x); }
+
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __x) { return emplace(std::move(__x)); }
+
+ template <class _Kp>
+ requires(__is_transparent_v<_Compare> && is_constructible_v<value_type, _Kp>)
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(_Kp&& __x) {
+ return emplace(std::forward<_Kp>(__x));
+ }
+ _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, const value_type& __x) {
+ return emplace_hint(__hint, __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, value_type&& __x) {
+ return emplace_hint(__hint, std::move(__x));
+ }
+
+ template <class _Kp>
+ requires(__is_transparent_v<_Compare> && is_constructible_v<value_type, _Kp>)
+ _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, _Kp&& __x) {
+ return emplace_hint(__hint, std::forward<_Kp>(__x));
+ }
+
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
+ _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
+ if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
+ __reserve(__last - __first);
+ }
+ __append_so...
[truncated]
|
| // for feature-test macros | ||
| # include <version> | ||
|
|
||
| // standard required includes |
There was a problem hiding this comment.
since this touches flat_map as well. I'd like to do it in a separate patch and make this patch flat_set only
ldionne
requested changes
Feb 21, 2025
huixie90
force-pushed
the
hxie/flat_set
branch
from
950a788 to
326be4d
Compare
huixie90
force-pushed
the
hxie/flat_set
branch
3 times, most recently
from
fb94ba2 to
5f12c9c
Compare
ldionne
requested changes
Mar 14, 2025
libcxx/test/std/containers/container.adaptors/flat.set/helpers.h
Outdated
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp
Outdated
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains.pass.cpp
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count.pass.cpp
Show resolved
Hide resolved
libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range.pass.cpp
Show resolved
Hide resolved
Comment on lines
+122
to
+127
| _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __ra_iterator& __x, const __ra_iterator& __y) | ||
| requires three_way_comparable<_Iterator> | ||
| { | ||
| return __x.__iter_ <=> __y.__iter_; | ||
| } |
There was a problem hiding this comment.
IIUC the requires here is unnecessary. As specified in [container.reqmts]/39, /40, and /41, use of non-three-way-comparable iterator here is invalid, and the return type is required to be std::strong_ordering.
There was a problem hiding this comment.
As Hui was explaining to me just now, these requirements are added by containers. But if we want to reuse this iterator type in other contexts, these requirements might not apply and so we are probably better off with the more general implementation.
ldionne
approved these changes
Mar 21, 2025
libcxx/test/libcxx/containers/container.adaptors/flat.set/iterator.compile.pass.cpp
Outdated
Show resolved
Hide resolved
.../test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp
Outdated
Show resolved
Hide resolved
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/169/builds/9727 Here is the relevant piece of the build log for the reference |
This was referenced Mar 28, 2025
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.