🛠️ for flat_set

stl/inc/flat_set

@@ -86,7 +86,7 @@ public:
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
         : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
-        _Assert_after_sorted_input();
+        _STL_ASSERT(_Check_sorted(cbegin(), cend()), _Msg_not_sorted);
     }
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
@@ -228,25 +228,25 @@ public:
         }
     }
 
-    auto insert(const value_type& _Val) {
+    auto insert(const _Kty& _Val) {
         return _Emplace(_Val);
     }
-    auto insert(value_type&& _Val) {
+    auto insert(_Kty&& _Val) {
         return _Emplace(_STD move(_Val));
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
     auto insert(_Other&& _Val) {
         return _Emplace(_STD forward<_Other>(_Val));
     }
 
-    iterator insert(const_iterator _Hint, const value_type& _Val) {
+    iterator insert(const_iterator _Hint, const _Kty& _Val) {
         return _Emplace_hint(_Hint, _Val);
     }
-    iterator insert(const_iterator _Hint, value_type&& _Val) {
+    iterator insert(const_iterator _Hint, _Kty&& _Val) {
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
     iterator insert(const_iterator _Hint, _Other&& _Val) {
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
@@ -263,7 +263,15 @@ public:
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
-        _Get_cont().append_range(_STD forward<_Rng>(_Range));
+
+        _Container& _Cont = _Get_cont();
+        if constexpr (requires { _Cont.append_range(_STD forward<_Rng>(_Range)); }) {
+            _Cont.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            for (const auto& _Val : _Range) {
+                _Cont.insert(_Cont.end(), _Val);
+            }
+        }
         _Restore_invariants_after_insert<false>(_Old_size);
     }
 
@@ -280,8 +288,8 @@ public:
         return _STD move(_Get_cont());
     }
     void replace(container_type&& _Cont) {
+        _STL_ASSERT(_Check_sorted(_Cont.cbegin(), _Cont.cend()), _Msg_not_sorted);
         _Get_cont() = _STD move(_Cont);
-        _Assert_after_sorted_input();
     }
 
     iterator erase(iterator _Where) {
@@ -293,7 +301,7 @@ public:
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (
             _Keylt_transparent && !is_convertible_v<_Other, iterator> && !is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
@@ -339,11 +347,11 @@ public:
     }
 
     _NODISCARD size_type count(const _Kty& _Val) const {
-        if constexpr (!_Multi) {
-            return contains(_Val);
-        } else {
+        if constexpr (_Multi) {
             const auto [_First, _Last] = equal_range(_Val);
             return static_cast<size_type>(_Last - _First);
+        } else {
+            return contains(_Val);
         }
     }
     template <class _Other>
@@ -420,7 +428,7 @@ public:
         return _RANGES equal(_Lhs._Get_cont(), _Rhs._Get_cont());
     }
 
-    _NODISCARD friend _Synth_three_way_result<_Kty> operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+    _NODISCARD friend auto operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
         return _STD lexicographical_compare_three_way(
             _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
     }
@@ -430,27 +438,25 @@ public:
     }
 
 private:
-    void _Assert_after_sorted_input() const {
-        _STL_ASSERT(_STD is_sorted(cbegin(), cend(), _Get_comp_v()), "Input was not sorted!");
-        if constexpr (!_Multi) {
-            _STL_ASSERT(_Is_unique(), "Input was sorted but not unique!");
-        }
-    }
-
-    bool _Is_unique() const {
-        if (empty()) {
-            return true;
-        }
-        const const_iterator _End = cend();
-        const_iterator _It        = cbegin();
-        while (++_It != _End) {
-            if (_Keys_equal(*(_It - 1), *_It)) {
-                return false;
+    bool _Check_sorted(const_iterator _It, const const_iterator _End) const {
+        if (_Multi) {
+            return _STD is_sorted(_It, _End, _Get_comp_v());
+        } else {
+            // sorted-unique
+            if (_It == _End) {
+                return true;
             }
+            while (++_It != _End) {
+                if (!_Compare(*(_It - 1), *_It)) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
     }
 
+    static constexpr const char* _Msg_not_sorted = _Multi ? "Input was not sorted!" : "Input was not sorted-unique!";
+
     bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
         // check that _Val can be inserted before _Where
         if constexpr (_Multi) {
@@ -604,17 +610,18 @@ private:
         }
     }
 
-    void _Erase_dupes_if_needed() {
+    void _Erase_dupes_if_not_multi() {
         if constexpr (!_Multi) {
-            const iterator _End = end();
-            const iterator _New_end =
-                _STD unique(begin(), _End, [&](const _Kty& _Lhs, const _Kty& _Rhs) { return _Keys_equal(_Lhs, _Rhs); });
+            const auto _Equal_to = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
+                return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
+            };
+            const iterator _End     = end();
+            const iterator _New_end = _STD unique(begin(), _End, _Equal_to);
             _Get_cont().erase(_New_end, _End);
-
-            _STL_INTERNAL_CHECK(_Is_unique());
         }
     }
 
+
     template <bool _Presorted>
     void _Restore_invariants_after_insert(const size_type _Old_size) {
         auto _Comp              = _Get_comp_v();
@@ -625,14 +632,13 @@ private:
         if constexpr (!_Presorted) {
             _STD sort(_Old_end, _New_end, _Comp);
         } else {
-            _STL_ASSERT(_STD is_sorted(_Old_end, _New_end, _Comp), "Input was not sorted!");
+            _STL_ASSERT(_Check_sorted(_Old_end, _New_end), _Msg_not_sorted);
         }
 
         _STD inplace_merge(_Begin, _Old_end, _New_end, _Comp);
+        _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _New_end, _Comp));
-
-        _Erase_dupes_if_needed();
+        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
     }
 
     void _Make_invariants_fulfilled() {
@@ -649,10 +655,9 @@ private:
 
         _STD sort(_Begin_unsorted, _End, _Comp);
         _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Comp);
+        _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _End, _Comp));
-
-        _Erase_dupes_if_needed();
+        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
     }
 
     template <class _Lty, class _Rty>
@@ -663,14 +668,6 @@ private:
         return _DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs);
     }
 
-    template <class _Lty, class _Rty>
-    _NODISCARD bool _Keys_equal(const _Lty& _Lhs, const _Rty& _Rhs) const
-        noexcept(noexcept(!_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs))) {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
-
-        return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
-    }
-
     _NODISCARD const _Container& _Get_cont() const noexcept {
         return _My_pair._Myval2;
     }
@@ -730,7 +727,7 @@ _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.set.erasure]/5)
     _Clear_scope_guard<flat_set<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
     _Guard._Clearable        = nullptr;
     return _Erased_count;
 }
@@ -739,7 +736,7 @@ _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.multiset.erasure]/5)
     _Clear_scope_guard<flat_multiset<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
     _Guard._Clearable        = nullptr;
     return _Erased_count;
 }

tests/std/tests/P1222R4_flat_set/test.cpp

@@ -8,6 +8,7 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <random>
 #include <vector>
 
 using namespace std;
@@ -235,6 +236,107 @@ void test_insert_2() {
     }
 }
 
+struct val_comparer {
+    const auto& extract_key(const auto& obj) const {
+        if constexpr (requires { void(obj.val); }) {
+            return obj.val;
+        } else {
+            return obj;
+        }
+    }
+
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
+
+void test_comparer_application() {
+    struct int_holder {
+        int val;
+        bool operator<(const int_holder&) const  = delete;
+        bool operator==(const int_holder&) const = delete;
+    };
+
+    flat_set<int_holder, val_comparer> fs{{0}, {3}, {1}, {0}, {5}};
+    assert(fs.contains(0));
+    assert(!fs.contains(2));
+    fs.insert(fs.begin(), int_holder{4});
+    fs.insert(2);
+    assert(fs.contains(4));
+    assert(fs.contains(int_holder{2}));
+
+    assert(fs.lower_bound(3) == fs.lower_bound(int_holder{3}));
+    fs.erase(2);
+    assert(!fs.contains(int_holder{2}));
+}
+
+void test_insert_3() {
+    // test that flat_set::insert(K&&) doesn't modify input for failed insertion.
+    struct int_holder {
+        int val;
+        mutable bool converted = false;
+
+        explicit operator int() const {
+            converted = true;
+            return val;
+        }
+    };
+
+    flat_set<int, val_comparer> fs{0, 3, 5};
+
+    assert_all_requirements_and_equals(fs, {0, 3, 5});
+
+    int_holder holder{3};
+    assert(!holder.converted);
+
+    fs.insert(holder);
+    assert(!holder.converted);
+    assert_all_requirements_and_equals(fs, {0, 3, 5});
+
+    holder.val = 1;
+    fs.insert(holder);
+    assert(holder.converted);
+    assert_all_requirements_and_equals(fs, {0, 1, 3, 5});
+}
+
+void test_insert_4() {
+    // test that hinted insertion is robust against invalid hints.
+    mt19937 eng(42);
+
+    uniform_int_distribution<int> dist_seq(0, 20);
+
+    vector<int> seq(200);
+    for (int& val : seq) {
+        val = dist_seq(eng);
+    }
+
+    {
+        flat_multiset<int> with_hint, no_hint;
+        for (const int val : seq) {
+            uniform_int_distribution<int> dist_idx(0, int(with_hint.size()));
+            auto random_hint = with_hint.begin() + dist_idx(eng);
+            with_hint.insert(random_hint, val);
+            no_hint.insert(val);
+        }
+
+        assert(with_hint == no_hint);
+    }
+
+    {
+        flat_set<int> with_hint, no_hint;
+        for (const int val : seq) {
+            uniform_int_distribution<int> dist_idx(0, int(with_hint.size()));
+            auto random_hint = with_hint.begin() + dist_idx(eng);
+            with_hint.insert(random_hint, val);
+            no_hint.insert(val);
+        }
+
+        assert(with_hint == no_hint);
+    }
+}
+
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
@@ -342,8 +444,8 @@ void test_count() {
     flat_set<int> fs{2};
     assert(fs.count(1) == 0);
 
-    flat_multiset<int> fs2{1, 2, 2, 3};
-    assert(fs2.count(2) == 2);
+    flat_multiset<int> fs2{10, 20, 20, 30};
+    assert(fs2.count(20) == 2);
 }
 
 int main() {
@@ -363,7 +465,10 @@ int main() {
     test_insert_1<deque<int>>();
     test_insert_2<vector<int>>();
     test_insert_2<deque<int>>();
+    test_insert_3();
+    test_insert_4();
 
+    test_comparer_application();
     test_non_static_comparer();
 
     test_extract<flat_set<int>>();