[libc++] implement std::flat_set

review

review

clang-format

CI

deduction

CI

CI again

CI again

Author: huixie90

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
 -----------------------------

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)","","",""

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

libcxx/include/__flat_set/flat_set.h

@@ -0,0 +1,59 @@
+// -*- 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
+#define _LIBCPP_FLAT_SET
+
+/*
+  Header <flat_set> synopsis
+
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+
+namespace std {
+  // [flat.set], class template flat_set
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+    class flat_set;
+
+  struct sorted_unique_t { explicit sorted_unique_t() = default; };
+  inline constexpr sorted_unique_t sorted_unique{};
+
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;
+
+  // [flat.set.erasure], erasure for flat_set
+  template<class Key, class Compare, class KeyContainer, class Predicate>
+    typename flat_set<Key, Compare, KeyContainer>::size_type
+      erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
+}
+*/
+
+#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
+#  include <__cxx03/__config>
+#else
+#  include <__config>
+
+#  if _LIBCPP_STD_VER >= 23
+#    include <__flat_map/sorted_unique.h>
+#    include <__flat_set/flat_set.h>
+#  endif
+
+// for feature-test macros
+#  include <version>
+
+// standard required includes
+#  include <compare>
+#  include <initializer_list>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
+
+#endif // _LIBCPP_FLAT_SET

libcxx/include/flat_set

@@ -1263,6 +1263,22 @@ module std [system] {
     export *
   }
 
+  module flat_set {
+    module flat_set                       {
+      header "__flat_set/flat_set.h"
+      export std.vector.vector
+      export std.vector.fwd
+    }
+    module sorted_unique                  { 
+      header "__flat_map/sorted_unique.h" 
+      export *
+    }
+
+    header "flat_set"
+    export std.flat_map.sorted_unique
+    export *
+  }
+
   module format {
     module buffer                             {
       header "__format/buffer.h"

libcxx/include/module.modulemap

@@ -53,9 +53,6 @@ module;
 #  if __has_include(<debugging>)
 #    error "please update the header information for <debugging> in headers_not_available in utils/libcxx/header_information.py"
 #  endif // __has_include(<debugging>)
-#  if __has_include(<flat_set>)
-#    error "please update the header information for <flat_set> in headers_not_available in utils/libcxx/header_information.py"
-#  endif // __has_include(<flat_set>)
 #  if __has_include(<generator>)
 #    error "please update the header information for <generator> in headers_not_available in utils/libcxx/header_information.py"
 #  endif // __has_include(<generator>)

libcxx/modules/std.compat.cppm.in

@@ -65,6 +65,7 @@ module;
 #include <expected>
 #include <filesystem>
 #include <flat_map>
+#include <flat_set>
 #include <format>
 #include <forward_list>
 #if _LIBCPP_HAS_LOCALIZATION
@@ -162,9 +163,6 @@ module;
 #  if __has_include(<debugging>)
 #    error "please update the header information for <debugging> in headers_not_available in utils/libcxx/header_information.py"
 #  endif // __has_include(<debugging>)
-#  if __has_include(<flat_set>)
-#    error "please update the header information for <flat_set> in headers_not_available in utils/libcxx/header_information.py"
-#  endif // __has_include(<flat_set>)
 #  if __has_include(<generator>)
 #    error "please update the header information for <generator> in headers_not_available in utils/libcxx/header_information.py"
 #  endif // __has_include(<generator>)

libcxx/modules/std.cppm.in

@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 export namespace std {
-#if 0
+#if _LIBCPP_STD_VER >= 23
   // [flat.set], class template flat_­set
   using std::flat_set;
 
@@ -19,7 +19,9 @@ export namespace std {
 
   // [flat.set.erasure], erasure for flat_­set
   using std::erase_if;
+#endif // _LIBCPP_STD_VER >= 23
 
+#if 0
   // [flat.multiset], class template flat_­multiset
   using std::flat_multiset;
 

libcxx/modules/std/flat_set.inc

@@ -0,0 +1,226 @@
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-hardening-mode=none
+// REQUIRES: libcpp-hardening-mode=debug
+// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
+
+// <flat_set>
+
+// flat_set(container_type , const key_compare& __comp = key_compare())
+// flat_set(const container_type&  , const _Allocator& )
+// flat_set(const container_type&  , const key_compare&, const _Allocator& )
+// void replace(container_type&& )
+//
+
+#include <flat_set>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  using M = std::flat_set<int>;
+
+  TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}); }()),
+                             "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {4, 2, 3}); }()),
+                             "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}, std::less<int>{}); }()),
+                             "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {4, 2, 3}, std::less<int>{}); }()),
+                             "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector keys{2, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, keys, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector keys{4, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, keys, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector keys{2, 2, 3};
+        const std::allocator<int> alloc{};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, keys, comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector keys{4, 2, 3};
+        const std::allocator<int> alloc{};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, keys, comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{2, 2, 3};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, v.begin(), v.end(), comp);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{4, 2, 3};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, v.begin(), v.end(), comp);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{2, 2, 3};
+        const std::less<int> comp{};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v.begin(), v.end(), comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{4, 2, 3};
+        const std::less<int> comp{};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v.begin(), v.end(), comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{2, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v.begin(), v.end(), alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{4, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v.begin(), v.end(), alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{2, 2, 3};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, v, comp);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{4, 2, 3};
+        const std::less<int> comp{};
+        M m(std::sorted_unique, v, comp);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{2, 2, 3};
+        const std::less<int> comp{};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v, comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{4, 2, 3};
+        const std::less<int> comp{};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v, comp, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{2, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{4, 2, 3};
+        const std::allocator<int> alloc{};
+        M m(std::sorted_unique, v, alloc);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{2, 2, 3};
+        M m;
+        m.insert(std::sorted_unique, v.begin(), v.end());
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        const std::vector<int> v{4, 2, 3};
+        M m;
+        m.insert(std::sorted_unique, v.begin(), v.end());
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{2, 2, 3};
+        M m;
+        m.insert(std::sorted_unique, v);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::initializer_list<int> v{4, 2, 3};
+        M m;
+        m.insert(std::sorted_unique, v);
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::vector keys{1, 1, 3};
+        M m;
+        m.replace(std::move(keys));
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+  TEST_LIBCPP_ASSERT_FAILURE(
+      ([] {
+        std::vector keys{2, 1, 3};
+        M m;
+        m.replace(std::move(keys));
+      }()),
+      "Either the key container is not sorted or it contains duplicates");
+
+  return 0;
+}