[libcxx-commits] [libcxx] [libc++] Implement P0429R9 `std::flat_map` (PR #98643)
via libcxx-commits
libcxx-commits at lists.llvm.org
Sat Oct 26 05:48:13 PDT 2024
https://github.com/huixie90 updated https://github.com/llvm/llvm-project/pull/98643
>From 15efacfa48adb2e922465dadadf3fc4d78ddf69a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 12 Jul 2024 13:01:52 +0100
Subject: [PATCH 01/40] [libc++] Implement P0429R9 `std::flat_map`
---
libcxx/docs/Status/Cxx23Papers.csv | 2 +-
libcxx/include/CMakeLists.txt | 3 +
libcxx/include/__flat_map/flat_map.h | 1231 ++++++++++++++++++++
libcxx/include/__flat_map/sorted_unique.h | 31 +
libcxx/include/__memory/allocator_traits.h | 3 +
libcxx/include/flat_map | 72 ++
libcxx/include/module.modulemap | 8 +
7 files changed, 1349 insertions(+), 1 deletion(-)
create mode 100644 libcxx/include/__flat_map/flat_map.h
create mode 100644 libcxx/include/__flat_map/sorted_unique.h
create mode 100644 libcxx/include/flat_map
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index c64f1c4171fce1..6f1626da73507e 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -52,7 +52,7 @@
"`P2443R1 <https://wg21.link/P2443R1>`__","``views::chunk_by``","2022-02 (Virtual)","|Complete|","18.0",""
"","","","","",""
"`P0009R18 <https://wg21.link/P0009R18>`__","mdspan: A Non-Owning Multidimensional Array Reference","2022-07 (Virtual)","|Complete|","18.0",""
-"`P0429R9 <https://wg21.link/P0429R9>`__","A Standard ``flat_map``","2022-07 (Virtual)","","",""
+"`P0429R9 <https://wg21.link/P0429R9>`__","A Standard ``flat_map``","2022-07 (Virtual)","|In progress|","",""
"`P1169R4 <https://wg21.link/P1169R4>`__","``static operator()``","2022-07 (Virtual)","|Complete|","16.0",""
"`P1222R4 <https://wg21.link/P1222R4>`__","A Standard ``flat_set``","2022-07 (Virtual)","","",""
"`P1223R5 <https://wg21.link/P1223R5>`__","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","2022-07 (Virtual)","|Complete|","19.0",""
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 506ed721d0843e..c59a63e69facf0 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -358,6 +358,8 @@ set(files
__filesystem/recursive_directory_iterator.h
__filesystem/space_info.h
__filesystem/u8path.h
+ __flat_map/flat_map.h
+ __flat_map/sorted_unique.h
__format/buffer.h
__format/concepts.h
__format/container_adaptor.h
@@ -957,6 +959,7 @@ set(files
ext/hash_set
fenv.h
filesystem
+ flat_map
float.h
format
forward_list
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
new file mode 100644
index 00000000000000..25b0f5979de56a
--- /dev/null
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -0,0 +1,1231 @@
+// -*- 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_MAP_FLAT_MAP_H
+#define _LIBCPP___FLAT_MAP_FLAT_MAP_H
+
+#include <__algorithm/ranges_equal.h>
+#include <__algorithm/ranges_lexicographical_compare.h>
+#include <__algorithm/ranges_lower_bound.h>
+#include <__algorithm/ranges_sort.h>
+#include <__algorithm/ranges_unique.h>
+#include <__compare/synth_three_way.h>
+#include <__config>
+#include <__flat_map/sorted_unique.h>
+#include <__functional/is_transparent.h>
+#include <__functional/operations.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.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/container_compatible_range.h>
+#include <__ranges/zip_view.h>
+#include <__utility/pair.h>
+#include <initializer_list>
+#include <stdexcept>
+#include <vector>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Key,
+ class _Tp,
+ class _Compare = less<_Key>,
+ class _KeyContainer = vector<_Key>,
+ class _MappedContainer = vector<_Tp>>
+class flat_map {
+ template <bool _Const>
+ struct __iterator;
+
+public:
+ // types
+ using key_type = _Key;
+ using mapped_type = _Tp;
+ using value_type = pair<key_type, mapped_type>;
+ using key_compare = _Compare;
+ using reference = pair<const key_type&, mapped_type&>;
+ using const_reference = pair<const key_type&, const mapped_type&>;
+ using size_type = size_t;
+ using difference_type = ptrdiff_t;
+ using iterator = __iterator<false>; // see [container.requirements]
+ using const_iterator = __iterator<true>; // see [container.requirements]
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using key_container_type = _KeyContainer;
+ using mapped_container_type = _MappedContainer;
+
+ class value_compare {
+ private:
+ key_compare __comp_;
+ value_compare(key_compare __c) : __comp_(__c) {}
+
+ public:
+ _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
+ return __comp_(__x.first, __y.first);
+ }
+ };
+
+ struct containers {
+ key_container_type keys;
+ mapped_container_type values;
+ };
+
+private:
+ template <class _Allocator>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __allocator_ctor_constraint =
+ _And<uses_allocator<key_container_type, _Allocator>, uses_allocator<mapped_container_type, _Allocator>>::value;
+
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __is_compare_transparent = __is_transparent_v<_Compare, _Compare>;
+
+ template <bool _Const>
+ struct __iterator {
+ private:
+ using __key_iterator = ranges::iterator_t<__maybe_const<_Const, key_container_type>>;
+ using __mapped_iterator = ranges::iterator_t<__maybe_const<_Const, mapped_container_type>>;
+ using __reference = conditional_t<_Const, flat_map::const_reference, flat_map::reference>;
+
+ struct __arrow_proxy {
+ __reference __ref_;
+ _LIBCPP_HIDE_FROM_ABI __reference* operator->() { return std::addressof(__ref_); }
+ };
+
+ __key_iterator __key_iter_;
+ __mapped_iterator __mapped_iter_;
+
+ public:
+ using iterator_concept = random_access_iterator_tag;
+ using iterator_category = input_iterator_tag;
+ using value_type = flat_map::value_type;
+ using difference_type = flat_map::difference_type;
+
+ _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+ _LIBCPP_HIDE_FROM_ABI __iterator(__iterator<!_Const> __i)
+ requires _Const && convertible_to<ranges::iterator_t<key_container_type>, __key_iterator> &&
+ convertible_to<ranges::iterator_t<mapped_container_type>, __mapped_iterator>
+ : __key_iter_(std::move(__i.__key_iter_)), __mapped_iter_(std::move(__i.__mapped_iter_)) {}
+
+ _LIBCPP_HIDE_FROM_ABI __iterator(__key_iterator __key_iter, __mapped_iterator __mapped_iter)
+ : __key_iter_(std::move(__key_iter)), __mapped_iter_(std::move(__mapped_iter)) {}
+
+ _LIBCPP_HIDE_FROM_ABI __reference operator*() const { return __reference(*__key_iter_, *__mapped_iter_); }
+ _LIBCPP_HIDE_FROM_ABI __arrow_proxy operator->() const { return __arrow_proxy(**this); }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator& operator++() {
+ ++__key_iter_;
+ ++__mapped_iter_;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator operator++(int) {
+ __iterator __tmp(*this);
+ ++*this;
+ return __tmp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator& operator--() {
+ --__key_iter_;
+ --__mapped_iter_;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator operator--(int) {
+ __iterator __tmp(*this);
+ --*this;
+ return __tmp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator& operator+=(difference_type __x) {
+ __key_iter_ += __x;
+ __mapped_iter_ += __x;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __iterator& operator-=(difference_type __x) {
+ __key_iter_ += __x;
+ __mapped_iter_ += __x;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI __reference operator[](difference_type __n) const { return *(*this + __n); }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+ return __x.__key_iter_ == __y.__key_iter_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend bool operator<(const __iterator& __x, const __iterator& __y) {
+ return __x.__key_iter_ < __y.__key_iter_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend bool operator<(const __iterator& __x, const __iterator& __y) { return __y < __x; }
+
+ _LIBCPP_HIDE_FROM_ABI friend bool operator<=(const __iterator& __x, const __iterator& __y) { return !(__y < __x); }
+
+ _LIBCPP_HIDE_FROM_ABI friend bool operator>=(const __iterator& __x, const __iterator& __y) { return !(__x < __y); }
+
+ _LIBCPP_HIDE_FROM_ABI friend auto operator<=>(const __iterator& __x, const __iterator& __y)
+ requires three_way_comparable<__key_iterator>
+ {
+ return __x.__key_iter_ <=> __y.__key_iter_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend __iterator operator+(const __iterator& __i, difference_type __n) {
+ auto __tmp = __i;
+ __tmp += __n;
+ return __tmp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend __iterator operator+(difference_type __n, const __iterator& __i) { return __i + __n; }
+
+ _LIBCPP_HIDE_FROM_ABI friend __iterator operator-(const __iterator& __i, difference_type __n) {
+ auto __tmp = __i;
+ __tmp -= __n;
+ return __tmp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend difference_type operator-(const __iterator& __x, const __iterator& __y) {
+ return difference_type(__x.__key_iter_ - __y.__key_iter_);
+ }
+ };
+
+public:
+ // [flat.map.cons], construct/copy/destroy
+ _LIBCPP_HIDE_FROM_ABI flat_map() : flat_map(key_compare()) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(const flat_map& __other, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{},
+ __alloc,
+ __other.__containers_.keys,
+ __other.__containers_.values,
+ __other.__compare_) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{},
+ __alloc,
+ std::move(__other.__containers_.keys),
+ std::move(__other.__containers_.values),
+ std::move(__other.__compare_)) {}
+
+ _LIBCPP_HIDE_FROM_ABI flat_map(
+ key_container_type __key_cont, mapped_container_type __mapped_cont, const key_compare& __comp = key_compare())
+ : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
+ __sort_and_unique();
+ }
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(const key_container_type& __key_cont, const mapped_container_type& __mapped_cont, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
+ __sort_and_unique();
+ }
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(const key_container_type& __key_cont,
+ const mapped_container_type& __mapped_cont,
+ const key_compare& __comp,
+ const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
+ __sort_and_unique();
+ }
+
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t,
+ key_container_type __key_cont,
+ mapped_container_type __mapped_cont,
+ const key_compare& __comp = key_compare())
+ : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t,
+ const key_container_type& __key_cont,
+ const mapped_container_type& __mapped_cont,
+ const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t,
+ const key_container_type& __key_cont,
+ const mapped_container_type& __mapped_cont,
+ const key_compare& __comp,
+ const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {}
+
+ _LIBCPP_HIDE_FROM_ABI explicit flat_map(const key_compare& __comp) : __containers_(), __compare_(__comp) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI explicit flat_map(const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {}
+
+ template <class _InputIterator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
+ : __containers_(), __compare_(__comp) {
+ insert(__first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert(__first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert(__first, __last);
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range>
+ _LIBCPP_HIDE_FROM_ABI flat_map(from_range_t __fr, _Range&& __rg)
+ : flat_map(__fr, std::forward<_Range>(__rg), key_compare()) {}
+
+ template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(from_range_t, _Range&& __rg, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range>
+ _LIBCPP_HIDE_FROM_ABI flat_map(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_map(__comp) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert_range(std::forward<_Range>(__rg));
+ }
+
+ template <class _InputIterator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(
+ sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
+ : __containers_(), __compare_(__comp) {
+ insert(__s, __first, __last);
+ }
+ template <class _InputIterator, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t __s,
+ _InputIterator __first,
+ _InputIterator __last,
+ const key_compare& __comp,
+ const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
+ insert(__s, __first, __last);
+ }
+
+ template <class _InputIterator, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+ : flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
+ insert(__s, __first, __last);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI flat_map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+ : flat_map(__il.begin(), __il.end(), __comp) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(__il.begin(), __il.end(), __comp, __alloc) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(initializer_list<value_type> __il, const _Allocator& __alloc)
+ : flat_map(__il.begin(), __il.end(), __alloc) {}
+
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+ : flat_map(__s, __il.begin(), __il.end(), __comp) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(__s, __il.begin(), __il.end(), __comp, __alloc) {}
+
+ template <class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
+ _LIBCPP_HIDE_FROM_ABI flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const _Allocator& __alloc)
+ : flat_map(__s, __il.begin(), __il.end(), __alloc) {}
+
+ _LIBCPP_HIDE_FROM_ABI flat_map& operator=(initializer_list<value_type> __il) {
+ clear();
+ insert(__il);
+ return *this;
+ }
+
+ // iterators
+ _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept {
+ return iterator(__containers_.keys.begin(), __containers_.values.begin());
+ }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept {
+ return const_iterator(__containers_.keys.begin(), __containers_.values.begin());
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator end() noexcept {
+ return iterator(__containers_.keys.end(), __containers_.values.end());
+ }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept {
+ return const_iterator(__containers_.keys.end(), __containers_.values.end());
+ }
+
+ _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+ _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { 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.map.capacity], capacity
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __containers_.keys.empty(); }
+
+ _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __containers_.keys.size(); }
+
+ _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept {
+ return std::min<size_type>(__containers_.keys.max_size(), __containers_.values.max_size());
+ }
+
+ // [flat.map.access], element access
+ _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __x) { return try_emplace(__x).first->second; }
+
+ _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __x) { return try_emplace(std::move(__x)).first->second; }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](_Kp&& __x) {
+ return try_emplace(std::forward<_Kp>(__x)).first->second;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __x) {
+ auto __it = find(__x);
+ if (__it == end()) {
+ __throw_out_of_range("flat_map::at(const key_type&): Key does not exist");
+ }
+ return (*__it).second;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __x) const {
+ auto __it = find(__x);
+ if (__it == end()) {
+ __throw_out_of_range("flat_map::at(const key_type&) const: Key does not exist");
+ }
+ return (*__it).second;
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI mapped_type& at(const _Kp& __x) {
+ static_assert(requires { find(__x); }, "flat_map::at(const K& x): find(x) needs to be well-formed");
+ auto __it = find(__x);
+ if (__it == end()) {
+ __throw_out_of_range("flat_map::at(const K&): Key does not exist");
+ }
+ return (*__it).second;
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const _Kp& __x) const {
+ static_assert(requires { find(__x); }, "flat_map::at(const K& x) const: find(x) needs to be well-formed");
+ auto __it = find(__x);
+ if (__it == end()) {
+ __throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
+ }
+ return (*__it).second;
+ }
+
+ // [flat.map.modifiers], modifiers
+ template <class... _Args>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+ std::pair<key_type, value_type> __pair(std::forward<_Args>(__args)...);
+ return __binary_search_emplace_impl(std::move(__pair));
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
+ _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
+ std::pair<key_type, value_type> __pair(std::forward<_Args>(__args)...);
+ if (__is_hint_correct(__hint, __pair.first)) {
+ if (__compare_(__pair.first, __hint->first)) {
+ return __emplace_impl(__hint, std::move(__pair));
+ } else {
+ // key equals
+ auto __dist = __hint - cbegin();
+ return iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist);
+ }
+ } else {
+ return __binary_search_emplace_impl(std::move(__pair)).first;
+ }
+ }
+
+ _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)); }
+
+ _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 _Pp>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Pp>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(_Pp&& __x) {
+ return emplace(std::forward<_Pp>(__x));
+ }
+
+ template <class _Pp>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Pp>
+ _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, _Pp&& __x) {
+ return emplace_hint(__hint, std::forward<_Pp>(__x));
+ }
+
+ template <class _InputIterator>
+ _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
+ insert(ranges::subrange<_InputIterator>(std::move(__first), std::move(__last)));
+ }
+
+ template <class _InputIterator>
+ void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) {
+ if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
+ __reserve_impl(__last - __first);
+ }
+
+ auto __it = begin();
+ auto __end = end();
+ while (__first != __last) {
+ value_type __pair(*__first);
+ __it = ranges::lower_bound(__it, __end, __compare_, &containers::keys);
+ if (__it == __end || __compare_(__pair.first, __it->first)) {
+ __it = __emplace_impl(__it, std::move(__pair));
+ }
+ ++__it;
+ ++__first;
+ }
+ }
+
+ template <_ContainerCompatibleRange<value_type> _Range>
+ _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+ if constexpr (ranges::sized_range<_Range>) {
+ __reserve_impl(ranges::size(__range));
+ }
+
+ auto __last = ranges::end(__range);
+ for (auto __it = ranges::begin(__range); __it != __last; ++__it) {
+ __binary_search_emplace_impl(value_type(*__it));
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
+
+ _LIBCPP_HIDE_FROM_ABI void insert(sorted_unique_t __s, initializer_list<value_type> __il) {
+ insert(__s, __il.begin(), __il.end());
+ }
+
+ _LIBCPP_HIDE_FROM_ABI containers extract() && {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ return std::move(__containers_);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (...) {
+ clear();
+ throw;
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void replace(key_container_type&& __key_cont, mapped_container_type&& __mapped_cont) {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ __containers_.keys = std::move(__key_cont);
+ __containers_.values = std::move(__mapped_cont);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (...) {
+ clear();
+ throw;
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<mapped_type, _Args...>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __key, _Args&&... __args) {
+ return __binary_search_try_emplace_impl(__key, std::forward<_Args>(__args)...);
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<mapped_type, _Args...>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __key, _Args&&... __args) {
+ return __binary_search_try_emplace_impl(std::move(__key), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Kp, class... _Args>
+ requires __is_compare_transparent && is_constructible_v<key_type, _Kp> &&
+ is_constructible_v<mapped_type, _Args...> && is_convertible_v<_Kp&&, const_iterator> &&
+ is_convertible_v<_Kp&&, iterator>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(_Kp&& __key, _Args&&... __args) {
+ return __binary_search_try_emplace_impl(std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<mapped_type, _Args...>
+ _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, const key_type& __key, _Args&&... __args) {
+ return try_emplace_hint_impl(__hint, __key, std::forward<_Args>(__args)...);
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<mapped_type, _Args...>
+ _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, key_type&& __key, _Args&&... __args) {
+ return try_emplace_hint_impl(__hint, std::move(__key), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Kp, class... _Args>
+ requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type, _Args...>
+ _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
+ return try_emplace_hint_impl(__hint, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Mapped>
+ requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(__key, std::forward<_Mapped>(__obj));
+ }
+
+ template <class _Mapped>
+ requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(std::move(__key), std::forward<_Mapped>(__obj));
+ }
+
+ template <class _Kp, class _Mapped>
+ requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_assignable_v<mapped_type&, _Mapped> &&
+ is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(_Kp&& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(std::forward<_Kp>(__key), std::forward<_Mapped>(__obj));
+ }
+
+ template <class _Mapped>
+ requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, const key_type& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(__key, std::forward<_Mapped>(__obj), __hint).first;
+ }
+
+ template <class _Mapped>
+ requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, key_type&& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(std::move(__key), std::forward<_Mapped>(__obj), __hint).first;
+ }
+
+ template <class _Kp, class _Mapped>
+ requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_assignable_v<mapped_type&, _Mapped> &&
+ is_constructible_v<mapped_type, _Mapped>
+ _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, _Kp&& __key, _Mapped&& __obj) {
+ return __insert_or_assign_impl(std::forward<_Kp>(__key), std::forward<_Mapped>(__obj), __hint).first;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
+ return __erase_impl(__position.__key_iter_, __position.__mapped_iter);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position) {
+ return __erase_impl(__position.__key_iter_, __position.__mapped_iter);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) {
+ auto __iter = find(__x);
+ if (__iter != end()) {
+ erase(__iter);
+ return 1;
+ }
+ return 0;
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI size_type erase(_Kp&& __x) {
+ auto __iter = find(__x);
+ if (__iter != end()) {
+ erase(__iter);
+ return 1;
+ }
+ return 0;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __key_it = __containers_.keys.erase(__first.__key_iter, __last.__key_iter);
+ auto __mapped_it = __containers_.values.erase(__first.__mapped_iter, __last.__mapped_iter);
+ return iterator(std::move(__key_it), std::move(__mapped_it));
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (const exception& __ex) {
+ clear();
+ throw flat_map_restore_error(
+ std::string("flat_map::erase: "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent. Reason: ") +
+ __ex.what());
+ } catch (...) {
+ clear();
+ throw flat_map_restore_error(
+ "flat_map::erase: "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent.");
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ swap(__compare_, __y.__compare_);
+ swap(__containers_.keys, __y.__containers_.keys);
+ swap(__containers_.values, __y.__containers_.values);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (...) {
+ clear();
+ __y.clear();
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void clear() noexcept {
+ __containers_.keys.clear();
+ __containers_.values.clear();
+ }
+
+ // observers
+ _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; }
+ _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__compare_); }
+ _LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; }
+ _LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; }
+
+ // map operations
+ _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __x) { return __find_impl(*this, __x); }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __x) const { return __find_impl(*this, __x); }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) {
+ return __find_impl(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Kp& __x) const {
+ return __find_impl(*this, __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __x) const { return contains(__x) ? 1 : 0; }
+
+ template <class _Kp>
+ _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const {
+ return contains(__x) ? 1 : 0;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
+
+ template <class _Kp>
+ _LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const {
+ return find(__x) != end();
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { return __lower_bound_impl<iterator>(*this, __x); }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const {
+ return __lower_bound_impl<const_iterator>(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) {
+ return __lower_bound_impl<iterator>(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const {
+ return __lower_bound_impl<const_iterator>(*this, __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound_impl<iterator>(*this, __x); }
+
+ _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const {
+ return __upper_bound_impl<const_iterator>(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) {
+ return __upper_bound_impl<iterator>(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const {
+ return __upper_bound_impl<iterator>(*this, __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __x) {
+ return __equal_range_impl(*this, __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __x) const {
+ return __equal_range_impl(*this, __x);
+ }
+
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _Kp& __x) {
+ return __equal_range_impl(*this, __x);
+ }
+ template <class _Kp>
+ requires __is_compare_transparent
+ _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _Kp& __x) const {
+ return __equal_range_impl(*this, __x);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI bool operator==(const flat_map& __x, const flat_map& __y) {
+ return ranges::equal(__x, __y);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<value_type>
+ operator<=>(const flat_map& __x, const flat_map& __y) {
+ return ranges::lexicographical_compare(__x, __y);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI void swap(flat_map& __x, flat_map& __y) noexcept { __x.swap(__y); }
+
+private:
+ struct __ctor_uses_allocator_tag {};
+ struct __ctor_uses_allocator_empty_tag {};
+ _LIBCPP_HIDE_FROM_ABI void __sort_and_unique() {
+ auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
+ ranges::sort(__zv, __compare_, &containers::keys);
+ auto __it = ranges::unique(__zv, __key_equiv(__compare_)).begin();
+ auto __dist = ranges::distance(__zv.begin(), __it);
+ __containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
+ __containers_.values.erase(__containers_.values.begin() + __dist, __containers_.values.end());
+ }
+
+ template <class _Allocator, class _KeyCont, class _MappedCont, class... _CompArg>
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(__ctor_uses_allocator_tag,
+ const _Allocator& __alloc,
+ _KeyCont&& __key_cont,
+ _MappedCont&& __mapped_cont,
+ _CompArg&&... __comp)
+ : __containers_{.keys = std::make_obj_using_allocator<key_container_type>(
+ __alloc, std::forward<_KeyCont>(__key_cont)),
+ .values = std::make_obj_using_allocator<mapped_container_type>(
+ __alloc, std::forward<_MappedCont>(__mapped_cont))},
+ __compare_(std::forward<_CompArg>(__comp)...) {}
+
+ template <class _Allocator, class... _CompArg>
+ _LIBCPP_HIDE_FROM_ABI flat_map(__ctor_uses_allocator_empty_tag, const _Allocator& __alloc, _CompArg&&... __comp)
+ : __containers_{.keys = std::make_obj_using_allocator<key_container_type>(__alloc),
+ .values = std::make_obj_using_allocator<mapped_container_type>(__alloc)},
+ __compare_(std::forward<_CompArg>(__comp)...) {}
+
+ template <class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) {
+ auto __it = __self.lower_bound(__key);
+ auto __last = __self.end();
+ if (__it == __last || __self.__compare_(__key, __it->first)) {
+ return __last;
+ }
+ return __it;
+ }
+
+ template <class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
+ auto __it = __self.lower_bound(__key);
+ auto __last = __self.end();
+ if (__it == __last || __self.__compare_(__key, __it->first)) {
+ return std::make_pair(std::move(__it), std::move(__last));
+ }
+ return std::make_pair(__it, std::next(__it));
+ }
+
+ template <class _Res, class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound_impl(_Self&& __self, _Kp& __x) {
+ return __binary_search_impl<_Res>(ranges::lower_bound, __self, __x);
+ }
+
+ template <class _Res, class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound_impl(_Self&& __self, _Kp& __x) {
+ return __binary_search_impl<_Res>(ranges::upper_bound, __self, __x);
+ }
+
+ template <class _Kp>
+ _LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) {
+ if (__hint != cbegin() && !__compare_(std::prev(__hint)->first, __key)) {
+ return false;
+ }
+ if (__hint != cend() && __compare(__hint->first, __key)) {
+ return false;
+ }
+ return true;
+ }
+
+ template <class _Res, class _Fn, class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static _Res __binary_search_impl(_Fn __search_fn, _Self&& __self, _Kp& __x) {
+ auto __key_iter = __search_fn(__self.__containers_.keys, __self.__compare_, __x);
+ auto __mapped_iter =
+ __self.__containers_.values.begin() +
+ static_cast<ranges::range_difference_t<mapped_container_type>>(
+ ranges::distance(__self.__containers_.values.begin(), __key_iter));
+
+ return _Res(std::move(__key_iter), std::move(__mapped_iter));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __binary_search_emplace_impl(std::pair<key_type, value_type>&& __pair) {
+ if (auto __it = lower_bound(__pair.first); __it == end() || __compare_(__pair.first, (*__it).first)) {
+ return pair<iterator, bool>(__emplace_impl(__it, std::move(__pair)), true);
+ } else {
+ return pair<iterator, bool>(std::move(__it), false);
+ }
+ }
+
+ template <class _Iter>
+ _LIBCPP_HIDE_FROM_ABI iterator __emplace_impl(_Iter&& __it, std::pair<key_type, value_type>&& __pair) {
+ return __try_emplace_impl(__it.__key_iter, __it.__mapped_iter, std::move(__pair.first), std::move(__pair.second));
+ }
+
+ template <class _KeyArg, class... _MArgs>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool>
+ __binary_search_try_emplace_impl(_KeyArg&& __key, _MArgs&&... __mapped_args) {
+ auto __key_it = ranges::lower_bound(__containers_.keys, __key, __compare_);
+ auto __mapped_it = __containers_.values.begin() + ranges::distance(__containers_.keys.begin(), __key_it);
+
+ if (__key_it == __containers_.keys.end() || __compare_(__key, *__key_it)) {
+ return pair<iterator, bool>(
+ __try_emplace_impl(std::move(__key_it),
+ std::move(__mapped_it),
+ std::forward<_KeyArg>(__key),
+ std::forward<_MArgs>(__mapped_args)...),
+ true);
+ } else {
+ return pair<iterator, bool>(iterator(std::move(__key_it), std::move(__mapped_it)), false);
+ }
+ }
+
+ template <class _Kp, class... _Args>
+ _LIBCPP_HIDE_FROM_ABI iterator try_emplace_hint_impl(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
+ if (__is_hint_correct(__hint, __key)) {
+ if (__compare_(__key, __hint->first)) {
+ return __try_emplace_impl(
+ __hint.__key_iter_, __hint.__mapped_iter_, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ } else {
+ // key equals
+ auto __dist = __hint - cbegin();
+ return iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist);
+ }
+ } else {
+ __binary_search_try_emplace_impl(std::forward<_Kp>(__key), std::forward<_Args>(__args)...).first;
+ }
+ }
+
+ template <class _Container>
+ static consteval bool __failed_emplacement_has_side_effects() {
+ // [container.reqmts] If an exception is thrown by an insert() or emplace() function while inserting a single
+ // element, that function has no effects. Except that there is exceptional cases...
+
+ // according to http://eel.is/c++draft/deque.modifiers#3 and http://eel.is/c++draft/vector.modifiers#2,
+ // the only exceptions that can cause side effects on single emplacement are by move constructors of
+ // non-Cpp17CopyInsertable T
+
+ using _Element = typename _Container::value_type;
+ if constexpr (is_nothrow_move_constructible_v<_Element>) {
+ return false;
+ } else {
+ if constexpr (requires { typename _Container::allocator_type; }) {
+ return !__is_cpp17_copy_insertable<typename _Container::allocator_type>::value;
+ } else {
+ return !__is_cpp17_copy_insertable<std::allocator<_Element>>::value;
+ }
+ }
+ }
+
+ struct flat_map_restore_error : runtime_error {
+ using runtime_error::runtime_error;
+ };
+
+ template <class _Container, class _Iter, class... _Args>
+ _LIBCPP_HIDE_FROM_ABI auto __safe_emplace(_Container& __container, _Iter&& __iter, _Args&&... __args) {
+ if constexpr (!__failed_emplacement_has_side_effects<_Container>()) {
+ // just let the exception be thrown as the container is still in its original state on exception
+ return __container.emplace(__iter, std::forward<_Args>(__args)...);
+ } else {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ return __container.emplace(__iter, std::forward<_Args>(__args)...);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (const exception& __ex) {
+ // The container might be in some unknown state and we can't get flat_map into consistent state
+ // because we have two containers. The only possible solution is to clear them out
+ clear();
+ throw flat_map_restore_error(
+ std::string("flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent. Reason: ") +
+ __ex.what());
+ } catch (...) {
+ // The container might be in some unknown state and we can't get flat_map into consistent state
+ // because we have two containers. The only possible solution is to clear them out
+ clear();
+ throw flat_map_restore_error(
+ "flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent.");
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+ }
+
+ template <class _Container, class _Iter>
+ _LIBCPP_HIDE_FROM_ABI auto __safe_erase(_Container& __container, _Iter&& __iter) {
+ // [container.reqmts] No erase(), clear(), pop_back() or pop_front() function throws an exception,
+ // except that there are exceptional cases
+
+ // http://eel.is/c++draft/deque.modifiers#5
+ // http://eel.is/c++draft/vector.modifiers#4
+
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ return __container.erase(__iter);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (const exception& __ex) {
+ // The container might be in some unknown state and we can't get flat_map into consistent state
+ // because we have two containers. The only possible solution is to clear them out
+ clear();
+ throw flat_map_restore_error(
+ std::string("flat_map: Erasing on the underlying container has failed. "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent. Reason: ") +
+ __ex.what());
+ } catch (...) {
+ // The container might be in some unknown state and we can't get flat_map into consistent state
+ // because we have two containers. The only possible solution is to clear them out
+ clear();
+ throw flat_map_restore_error(
+ "flat_map: Erasing on the underlying container has failed. "
+ "Unable to restore flat_map to previous state. Clear out the containers to make the two "
+ "containers consistent.");
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ template <class _IterK, class _IterM, class _KeyArg, class... _MArgs>
+ _LIBCPP_HIDE_FROM_ABI iterator
+ __try_emplace_impl(_IterK&& __it_key, _IterM&& __it_mapped, _KeyArg&& __key, _MArgs&&... __mapped_args) {
+ auto __key_it = __safe_emplace(__containers_.keys, __it_key, std::forward<_KeyArg>(__key));
+
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __mapped_it = __safe_emplace(__containers_.values, __it_mapped, std::forward<_MArgs>(__mapped_args)...);
+ return iterator(std::move(__key_it), std::move(__mapped_it));
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (const flat_map_restore_error&) {
+ // both containers already cleared out
+ throw;
+ } catch (...) {
+ // If the second emplace throws and it has no effects on `values`, we need to erase the emplaced key.
+ __safe_erase(__containers_.keys, __key_it);
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ template <class _Kp, class _Mapped, class... _Hint>
+ _LIBCPP_HIDE_FROM_ABI auto __insert_or_assign_impl(_Kp&& __key, _Mapped&& __mapped, _Hint&&... __hint) {
+ auto __r = try_emplace(__hint..., std::forward<_Kp>(__key), std::forward<_Mapped>(__mapped));
+ if (!__r.second) {
+ __r.first->second = std::forward<_Mapped>(__mapped);
+ }
+ return __r;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void __reserve_impl(size_t __size) {
+ if constexpr (requires { __containers_.keys.reserve(__size); }) {
+ __containers_.keys.reserve(__size);
+ }
+
+ if constexpr (requires { __containers_.values.reserve(__size); }) {
+ __containers_.values.reserve(__size);
+ }
+ }
+
+ template <class _KIter, class _MIter>
+ _LIBCPP_HIDE_FROM_ABI iterator __erase_impl(_KIter __k_iter, _MIter __m_iter) {
+ auto __key_iter = __safe_erase(__containers_.keys, __k_iter);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __mapped_iter = __safe_erase(__containers_.values, __m_iter);
+ return iterator(std::move(__key_iter), std::move(__mapped_iter));
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (const flat_map_restore_error&) {
+ // both containers already cleared out
+ throw;
+ } catch (...) {
+ // If the second erase throws, the first erase already happened. The flat_map is inconsistent.
+ clear();
+ throw flat_map_restore_error(
+ "flat_map::erase: Key has been erased but exception thrown on erasing mapped value. To make flat_map in "
+ "consistent state, clear out the flat_map");
+ }
+# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ }
+
+ containers __containers_;
+ [[no_unique_address]] key_compare __compare_;
+
+ struct __key_equiv {
+ __key_equiv(key_compare __c) : __comp_(__c) {}
+ bool operator()(const_reference __x, const_reference __y) const {
+ return !__comp_(__x.first, __y.first) && !__comp_(__y.first, __x.first);
+ }
+ key_compare __comp_;
+ };
+};
+
+template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare())
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ _Compare,
+ _KeyContainer,
+ _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Allocator>
+flat_map(_KeyContainer, _MappedContainer, _Allocator)
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ less<typename _KeyContainer::value_type>,
+ _KeyContainer,
+ _MappedContainer>;
+template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator)
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ _Compare,
+ _KeyContainer,
+ _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ _Compare,
+ _KeyContainer,
+ _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Allocator>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator)
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ less<typename _KeyContainer::value_type>,
+ _KeyContainer,
+ _MappedContainer>;
+template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+ -> flat_map<typename _KeyContainer::value_type,
+ typename _MappedContainer::value_type,
+ _Compare,
+ _KeyContainer,
+ _MappedContainer>;
+
+template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
+ -> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
+
+template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
+ -> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
+
+template <ranges::input_range _Range,
+ class _Compare = less<__iter_key_type<_Range>>,
+ class _Allocator = allocator<byte>>
+flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+ -> flat_map<__range_key_type<_Range>,
+ __range_mapped_type<_Range>,
+ _Compare,
+ vector<__range_key_type<_Range>, __alloc_rebind<_Allocator, __range_key_type<_Range>>>,
+ vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
+
+template <ranges::input_range _Range, class _Allocator>
+flat_map(from_range_t, _Range&&, _Allocator)
+ -> flat_map<__range_key_type<_Range>,
+ __range_mapped_type<_Range>,
+ less<__range_key_type<_Range>>,
+ vector<__range_key_type<_Range>, __alloc_rebind<_Allocator, __range_key_type<_Range>>>,
+ vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
+
+template <class _Key, class _Tp, class _Compare = less<_Key>>
+flat_map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
+
+template <class _Key, class _Tp, class _Compare = less<_Key>>
+flat_map(sorted_unique_t, initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
+
+template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
+struct uses_allocator<flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
+ : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___FLAT_MAP_FLAT_MAP_H
diff --git a/libcxx/include/__flat_map/sorted_unique.h b/libcxx/include/__flat_map/sorted_unique.h
new file mode 100644
index 00000000000000..0189a5ff1d5684
--- /dev/null
+++ b/libcxx/include/__flat_map/sorted_unique.h
@@ -0,0 +1,31 @@
+// -*- 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_MAP_SORTED_UNIQUE_H
+#define _LIBCPP___FLAT_MAP_SORTED_UNIQUE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct sorted_unique_t {
+ explicit sorted_unique_t() = default;
+};
+inline constexpr sorted_unique_t sorted_unique{};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___FLAT_MAP_SORTED_UNIQUE_H
diff --git a/libcxx/include/__memory/allocator_traits.h b/libcxx/include/__memory/allocator_traits.h
index f4d9679807ae01..3da2f0909fa99b 100644
--- a/libcxx/include/__memory/allocator_traits.h
+++ b/libcxx/include/__memory/allocator_traits.h
@@ -373,6 +373,9 @@ template <class _Traits, class _Tp>
using __rebind_alloc = typename _Traits::template rebind_alloc<_Tp>::other;
#endif
+template <class _Allocator, class _Tp>
+using __alloc_rebind = __rebind_alloc<allocator_traits<_Allocator>, _Tp>;
+
template <class _Alloc>
struct __check_valid_allocator : true_type {
using _Traits = std::allocator_traits<_Alloc>;
diff --git a/libcxx/include/flat_map b/libcxx/include/flat_map
new file mode 100644
index 00000000000000..7abda6ae5819d2
--- /dev/null
+++ b/libcxx/include/flat_map
@@ -0,0 +1,72 @@
+// -*- 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_MAP
+#define _LIBCPP_FLAT_MAP
+
+/*
+ Header <flat_map> synopsis
+
+#include <compare> // see [compare.syn]
+#include <initializer_list> // see [initializer.list.syn]
+
+namespace std {
+ // [flat.map], class template flat_map
+ template<class Key, class T, class Compare = less<Key>,
+ class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+ class flat_map;
+
+ struct sorted_unique_t { explicit sorted_unique_t() = default; };
+ inline constexpr sorted_unique_t sorted_unique{};
+
+ template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+ class Allocator>
+ struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,
+ Allocator>;
+
+ // [flat.map.erasure], erasure for flat_map
+ template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+ class Predicate>
+ typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+ erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+
+ // [flat.multimap], class template flat_multimap
+ template<class Key, class T, class Compare = less<Key>,
+ class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+ class flat_multimap;
+
+ struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
+ inline constexpr sorted_equivalent_t sorted_equivalent{};
+
+ template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+ class Allocator>
+ struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
+ Allocator>;
+
+ // [flat.multimap.erasure], erasure for flat_multimap
+ template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+ class Predicate>
+ typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+ erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+*/
+
+#include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
+#include <__flat_map/flat_map.h>
+#include <__flat_map/sorted_unique.h>
+#include <version>
+
+// standard required includes
+#include <compare>
+#include <initializer_list>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#endif // _LIBCPP_FLAT_MAP
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index f92e8bf5fc9aba..75cec4678a0544 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1222,6 +1222,14 @@ module std [system] {
export *
}
+ module flat_map {
+ module flat_map { header "__flat_map/flat_map.h" }
+ module sorted_unique { header "__flat_map/sorted_unique.h" }
+
+ head "flat_map"
+ export *
+ }
+
module format {
module buffer { header "__format/buffer.h" }
module concepts { header "__format/concepts.h" }
>From a37517fc7880b55f542a5844c266d1d0744a3270 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 17 Jul 2024 12:22:03 +0100
Subject: [PATCH 02/40] tests
---
libcxx/include/__flat_map/flat_map.h | 144 ++++--
.../flat.map/container_stability.pass.cpp | 69 +++
.../container.adaptors/NaiveStaticVector.h | 90 ++++
.../flat.map/clear.pass.cpp | 56 ++
.../container.adaptors/flat.map/comp.pass.cpp | 96 ++++
.../flat.map/contains.pass.cpp | 74 +++
.../flat.map/contains_transparent.pass.cpp | 53 ++
.../flat.map/count.pass.cpp | 73 +++
.../flat.map/count_transparent.pass.cpp | 53 ++
.../flat.map/empty.pass.cpp | 63 +++
.../flat.map/empty.verify.cpp | 25 +
.../flat.map/equal_range.pass.cpp | 85 +++
.../flat.map/equal_range_transparent.pass.cpp | 57 ++
.../flat.map/erase_key.pass.cpp | 114 ++++
.../flat.map/erase_key_transparent.pass.cpp | 119 +++++
.../container.adaptors/flat.map/find.pass.cpp | 78 +++
.../flat.map/find_transparent.pass.cpp | 56 ++
.../flat.map/flat.map.cons/alloc.pass.cpp | 50 ++
.../assign_initializer_list.pass.cpp | 65 +++
.../flat.map/flat.map.cons/compare.pass.cpp | 88 ++++
.../flat.map.cons/containers.pass.cpp | 228 ++++++++
.../flat.map.cons/containers_compare.pass.cpp | 246 +++++++++
.../flat.map/flat.map.cons/copy.pass.cpp | 91 ++++
.../flat.map.cons/copy_alloc.pass.cpp | 78 +++
.../copy_assign.addressof.compile.pass.cpp | 30 ++
.../flat.map.cons/copy_assign.pass.cpp | 110 ++++
.../flat.map/flat.map.cons/deduct.pass.cpp | 489 ++++++++++++++++++
.../flat.map/flat.map.cons/deduct.verify.cpp | 97 ++++
.../flat.map/flat.map.cons/default.pass.cpp | 72 +++
.../flat.map.cons/default_noexcept.pass.cpp | 58 +++
.../flat.map.cons/dtor_noexcept.pass.cpp | 54 ++
.../flat.map.cons/initializer_list.pass.cpp | 86 +++
.../initializer_list_compare.pass.cpp | 79 +++
.../flat.map/flat.map.cons/iter_iter.pass.cpp | 93 ++++
.../flat.map.cons/iter_iter_comp.pass.cpp | 103 ++++
.../iter_iter_stability.pass.cpp | 66 +++
.../flat.map/flat.map.cons/move.pass.cpp | 77 +++
.../flat.map.cons/move_alloc.pass.cpp | 84 +++
.../flat.map.cons/move_assign.pass.cpp | 108 ++++
.../flat.map.cons/move_assign_clears.pass.cpp | 84 +++
.../move_assign_noexcept.pass.cpp | 90 ++++
.../flat.map.cons/move_exceptions.pass.cpp | 76 +++
.../flat.map.cons/move_noexcept.pass.cpp | 110 ++++
.../flat.map.cons/sorted_container.pass.cpp | 129 +++++
.../sorted_iter_iter_comp.pass.cpp | 106 ++++
.../flat.map.erasure/erase_if.pass.cpp | 102 ++++
.../erase_if_exceptions.pass.cpp | 162 ++++++
.../flat.map/incomplete_type.pass.cpp | 34 ++
.../flat.map/insert_range.pass.cpp | 94 ++++
.../flat.map/insert_range_stability.pass.cpp | 54 ++
.../flat.map/insert_transparent.pass.cpp | 121 +++++
.../flat.map/iterator.pass.cpp | 98 ++++
.../flat.map/iterator_comparison.pass.cpp | 72 +++
...rator_concept_conformance.compile.pass.cpp | 142 +++++
.../flat.map/lower_bound.pass.cpp | 77 +++
.../flat.map/lower_bound_transparent.pass.cpp | 54 ++
.../flat.map/max_size.pass.cpp | 77 +++
.../flat.map/op_compare.pass.cpp | 97 ++++
...range_concept_conformance.compile.pass.cpp | 66 +++
.../flat.map/reverse_iterator.pass.cpp | 102 ++++
.../flat.map/types.pass.cpp | 86 +++
.../flat.map/upper_bound.pass.cpp | 77 +++
.../flat.map/upper_bound_transparent.pass.cpp | 54 ++
63 files changed, 5885 insertions(+), 36 deletions(-)
create mode 100644 libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 25b0f5979de56a..dc75ea6d64f8d7 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -12,13 +12,16 @@
#include <__algorithm/ranges_equal.h>
#include <__algorithm/ranges_lexicographical_compare.h>
#include <__algorithm/ranges_lower_bound.h>
-#include <__algorithm/ranges_sort.h>
+#include <__algorithm/ranges_stable_sort.h>
#include <__algorithm/ranges_unique.h>
+#include <__algorithm/ranges_upper_bound.h>
#include <__compare/synth_three_way.h>
+#include <__concepts/convertible_to.h>
#include <__config>
#include <__flat_map/sorted_unique.h>
#include <__functional/is_transparent.h>
#include <__functional/operations.h>
+#include <__iterator/concepts.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/ranges_iterator_traits.h>
@@ -26,11 +29,20 @@
#include <__memory/allocator_traits.h>
#include <__memory/uses_allocator.h>
#include <__memory/uses_allocator_construction.h>
+#include <__ranges/concepts.h>
#include <__ranges/container_compatible_range.h>
+#include <__ranges/ref_view.h>
+#include <__ranges/subrange.h>
#include <__ranges/zip_view.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/maybe_const.h>
#include <__utility/pair.h>
#include <initializer_list>
#include <stdexcept>
+#include <string>
#include <vector>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -50,14 +62,21 @@ class flat_map {
template <bool _Const>
struct __iterator;
+ template <class, class, class, class, class>
+ friend class flat_map;
+
public:
// types
- using key_type = _Key;
- using mapped_type = _Tp;
- using value_type = pair<key_type, mapped_type>;
- using key_compare = _Compare;
- using reference = pair<const key_type&, mapped_type&>;
- using const_reference = pair<const key_type&, const mapped_type&>;
+ using key_type = _Key;
+ using mapped_type = _Tp;
+ using value_type = pair<key_type, mapped_type>;
+ using key_compare = _Compare;
+ // TODO : the following is the spec, but not implementable for vector<bool>
+ // using reference = pair<const key_type&, mapped_type&>;
+ // using const_reference = pair<const key_type&, const mapped_type&>;
+ using reference = pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<_MappedContainer>>;
+ using const_reference =
+ pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<const _MappedContainer>>;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator = __iterator<false>; // see [container.requirements]
@@ -71,6 +90,7 @@ class flat_map {
private:
key_compare __comp_;
value_compare(key_compare __c) : __comp_(__c) {}
+ friend flat_map;
public:
_LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
@@ -95,7 +115,7 @@ class flat_map {
private:
using __key_iterator = ranges::iterator_t<__maybe_const<_Const, key_container_type>>;
using __mapped_iterator = ranges::iterator_t<__maybe_const<_Const, mapped_container_type>>;
- using __reference = conditional_t<_Const, flat_map::const_reference, flat_map::reference>;
+ using __reference = pair<iter_reference_t<__key_iterator>, iter_reference_t<__mapped_iterator>>;
struct __arrow_proxy {
__reference __ref_;
@@ -105,6 +125,8 @@ class flat_map {
__key_iterator __key_iter_;
__mapped_iterator __mapped_iter_;
+ friend flat_map;
+
public:
using iterator_concept = random_access_iterator_tag;
using iterator_category = input_iterator_tag;
@@ -170,7 +192,7 @@ class flat_map {
return __x.__key_iter_ < __y.__key_iter_;
}
- _LIBCPP_HIDE_FROM_ABI friend bool operator<(const __iterator& __x, const __iterator& __y) { return __y < __x; }
+ _LIBCPP_HIDE_FROM_ABI friend bool operator>(const __iterator& __x, const __iterator& __y) { return __y < __x; }
_LIBCPP_HIDE_FROM_ABI friend bool operator<=(const __iterator& __x, const __iterator& __y) { return !(__y < __x); }
@@ -203,7 +225,10 @@ class flat_map {
public:
// [flat.map.cons], construct/copy/destroy
- _LIBCPP_HIDE_FROM_ABI flat_map() : flat_map(key_compare()) {}
+ _LIBCPP_HIDE_FROM_ABI flat_map() noexcept(
+ is_nothrow_default_constructible_v<_KeyContainer> && is_nothrow_default_constructible_v<_MappedContainer> &&
+ is_nothrow_default_constructible_v<_Compare>)
+ : __containers_(), __compare_() {}
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
@@ -286,14 +311,14 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI explicit flat_map(const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {}
- template <class _InputIterator>
+ template <input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(__first, __last);
}
- template <class _InputIterator, class _Allocator>
+ template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
@@ -301,7 +326,7 @@ class flat_map {
insert(__first, __last);
}
- template <class _InputIterator, class _Allocator>
+ template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
@@ -330,13 +355,13 @@ class flat_map {
insert_range(std::forward<_Range>(__rg));
}
- template <class _InputIterator>
+ template <input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI flat_map(
sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(__s, __first, __last);
}
- template <class _InputIterator, class _Allocator>
+ template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t __s,
@@ -348,7 +373,7 @@ class flat_map {
insert(__s, __first, __last);
}
- template <class _InputIterator, class _Allocator>
+ template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
@@ -480,14 +505,14 @@ class flat_map {
template <class... _Args>
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
- std::pair<key_type, value_type> __pair(std::forward<_Args>(__args)...);
+ std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
return __binary_search_emplace_impl(std::move(__pair));
}
template <class... _Args>
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
- std::pair<key_type, value_type> __pair(std::forward<_Args>(__args)...);
+ std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
if (__is_hint_correct(__hint, __pair.first)) {
if (__compare_(__pair.first, __hint->first)) {
return __emplace_impl(__hint, std::move(__pair));
@@ -525,22 +550,30 @@ class flat_map {
return emplace_hint(__hint, std::forward<_Pp>(__x));
}
- template <class _InputIterator>
+ template <input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
- insert(ranges::subrange<_InputIterator>(std::move(__first), std::move(__last)));
+ if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
+ __reserve_impl(__last - __first);
+ }
+
+ for (; __first != __last; ++__first) {
+ __binary_search_emplace_impl(value_type(*__first));
+ }
}
- template <class _InputIterator>
+ template <input_iterator _InputIterator>
void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve_impl(__last - __first);
}
- auto __it = begin();
- auto __end = end();
+ auto __it = begin();
while (__first != __last) {
value_type __pair(*__first);
- __it = ranges::lower_bound(__it, __end, __compare_, &containers::keys);
+ auto __end = end();
+ __it = ranges::lower_bound(__it, __end, __pair.first, __compare_, [](const auto& __p) -> decltype(auto) {
+ return std::get<0>(__p);
+ });
if (__it == __end || __compare_(__pair.first, __it->first)) {
__it = __emplace_impl(__it, std::move(__pair));
}
@@ -727,6 +760,7 @@ class flat_map {
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ using std::swap;
swap(__compare_, __y.__compare_);
swap(__containers_.keys, __y.__containers_.keys);
swap(__containers_.values, __y.__containers_.values);
@@ -847,11 +881,15 @@ class flat_map {
friend _LIBCPP_HIDE_FROM_ABI void swap(flat_map& __x, flat_map& __y) noexcept { __x.swap(__y); }
private:
- struct __ctor_uses_allocator_tag {};
- struct __ctor_uses_allocator_empty_tag {};
+ struct __ctor_uses_allocator_tag {
+ explicit __ctor_uses_allocator_tag() = default;
+ };
+ struct __ctor_uses_allocator_empty_tag {
+ explicit __ctor_uses_allocator_empty_tag() = default;
+ };
_LIBCPP_HIDE_FROM_ABI void __sort_and_unique() {
auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
- ranges::sort(__zv, __compare_, &containers::keys);
+ ranges::stable_sort(__zv, __compare_, [](const auto& __p) -> decltype(auto) { return std::get<0>(__p); });
auto __it = ranges::unique(__zv, __key_equiv(__compare_)).begin();
auto __dist = ranges::distance(__zv.begin(), __it);
__containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
@@ -920,16 +958,16 @@ class flat_map {
template <class _Res, class _Fn, class _Self, class _Kp>
_LIBCPP_HIDE_FROM_ABI static _Res __binary_search_impl(_Fn __search_fn, _Self&& __self, _Kp& __x) {
- auto __key_iter = __search_fn(__self.__containers_.keys, __self.__compare_, __x);
+ auto __key_iter = __search_fn(__self.__containers_.keys, __x, __self.__compare_);
auto __mapped_iter =
__self.__containers_.values.begin() +
static_cast<ranges::range_difference_t<mapped_container_type>>(
- ranges::distance(__self.__containers_.values.begin(), __key_iter));
+ ranges::distance(__self.__containers_.keys.begin(), __key_iter));
return _Res(std::move(__key_iter), std::move(__mapped_iter));
}
- _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __binary_search_emplace_impl(std::pair<key_type, value_type>&& __pair) {
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __binary_search_emplace_impl(std::pair<key_type, mapped_type>&& __pair) {
if (auto __it = lower_bound(__pair.first); __it == end() || __compare_(__pair.first, (*__it).first)) {
return pair<iterator, bool>(__emplace_impl(__it, std::move(__pair)), true);
} else {
@@ -938,8 +976,8 @@ class flat_map {
}
template <class _Iter>
- _LIBCPP_HIDE_FROM_ABI iterator __emplace_impl(_Iter&& __it, std::pair<key_type, value_type>&& __pair) {
- return __try_emplace_impl(__it.__key_iter, __it.__mapped_iter, std::move(__pair.first), std::move(__pair.second));
+ _LIBCPP_HIDE_FROM_ABI iterator __emplace_impl(_Iter&& __it, std::pair<key_type, mapped_type>&& __pair) {
+ return __try_emplace_impl(__it.__key_iter_, __it.__mapped_iter_, std::move(__pair.first), std::move(__pair.second));
}
template <class _KeyArg, class... _MArgs>
@@ -1002,7 +1040,8 @@ class flat_map {
};
template <class _Container, class _Iter, class... _Args>
- _LIBCPP_HIDE_FROM_ABI auto __safe_emplace(_Container& __container, _Iter&& __iter, _Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI ranges::iterator_t<_Container>
+ __safe_emplace(_Container& __container, _Iter&& __iter, _Args&&... __args) {
if constexpr (!__failed_emplacement_has_side_effects<_Container>()) {
// just let the exception be thrown as the container is still in its original state on exception
return __container.emplace(__iter, std::forward<_Args>(__args)...);
@@ -1010,7 +1049,6 @@ class flat_map {
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- return __container.emplace(__iter, std::forward<_Args>(__args)...);
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (const exception& __ex) {
// The container might be in some unknown state and we can't get flat_map into consistent state
@@ -1143,6 +1181,11 @@ class flat_map {
};
template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+ requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+ !__is_allocator<_MappedContainer>::value &&
+ is_invocable_v<const _Compare&,
+ const typename _KeyContainer::value_type&,
+ const typename _KeyContainer::value_type&>)
flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare())
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
@@ -1151,13 +1194,22 @@ flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare())
_MappedContainer>;
template <class _KeyContainer, class _MappedContainer, class _Allocator>
+ requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
+ !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
flat_map(_KeyContainer, _MappedContainer, _Allocator)
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
less<typename _KeyContainer::value_type>,
_KeyContainer,
_MappedContainer>;
+
template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+ requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+ !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+ uses_allocator_v<_MappedContainer, _Allocator> &&
+ is_invocable_v<const _Compare&,
+ const typename _KeyContainer::value_type&,
+ const typename _KeyContainer::value_type&>)
flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator)
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
@@ -1166,6 +1218,11 @@ flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator)
_MappedContainer>;
template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+ requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+ !__is_allocator<_MappedContainer>::value &&
+ is_invocable_v<const _Compare&,
+ const typename _KeyContainer::value_type&,
+ const typename _KeyContainer::value_type&>)
flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
@@ -1174,13 +1231,22 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare()
_MappedContainer>;
template <class _KeyContainer, class _MappedContainer, class _Allocator>
+ requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
+ !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator)
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
less<typename _KeyContainer::value_type>,
_KeyContainer,
_MappedContainer>;
+
template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+ requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+ !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+ uses_allocator_v<_MappedContainer, _Allocator> &&
+ is_invocable_v<const _Compare&,
+ const typename _KeyContainer::value_type&,
+ const typename _KeyContainer::value_type&>)
flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
-> flat_map<typename _KeyContainer::value_type,
typename _MappedContainer::value_type,
@@ -1188,17 +1254,20 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
_KeyContainer,
_MappedContainer>;
-template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+template <input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+ requires(!__is_allocator<_Compare>::value)
flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
-template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+template <input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+ requires(!__is_allocator<_Compare>::value)
flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
template <ranges::input_range _Range,
class _Compare = less<__iter_key_type<_Range>>,
class _Allocator = allocator<byte>>
+ requires(!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value)
flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
-> flat_map<__range_key_type<_Range>,
__range_mapped_type<_Range>,
@@ -1207,6 +1276,7 @@ flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator(
vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
template <ranges::input_range _Range, class _Allocator>
+ requires __is_allocator<_Allocator>::value
flat_map(from_range_t, _Range&&, _Allocator)
-> flat_map<__range_key_type<_Range>,
__range_mapped_type<_Range>,
@@ -1215,9 +1285,11 @@ flat_map(from_range_t, _Range&&, _Allocator)
vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
template <class _Key, class _Tp, class _Compare = less<_Key>>
+ requires(!__is_allocator<_Compare>::value)
flat_map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
template <class _Key, class _Tp, class _Compare = less<_Key>>
+ requires(!__is_allocator<_Compare>::value)
flat_map(sorted_unique_t, initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
new file mode 100644
index 00000000000000..a76d78ac816ea5
--- /dev/null
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(key_container_type key_cont, mapped_container_type mapped_cont);
+//
+// libc++ uses stable_sort to ensure that flat_map's behavior matches map's,
+// in terms of which duplicate items are kept.
+// This tests a conforming extension.
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <flat_map>
+#include <random>
+#include <map>
+#include <vector>
+
+#include "test_macros.h"
+
+struct Mod256 {
+ bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
+};
+
+int main(int, char**)
+{
+ std::mt19937 randomness;
+ std::vector<uint16_t> values;
+ std::vector<std::pair<uint16_t, uint16_t>> pairs;
+ for (int i=0; i < 200; ++i) {
+ uint16_t r = randomness();
+ values.push_back(r);
+ pairs.emplace_back(r, r);
+ }
+
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs.begin(), pairs.end());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(values, values);
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs.begin(), pairs.end());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(values, values, Mod256());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs.begin(), pairs.end());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(values, values, std::allocator<int>());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs.begin(), pairs.end());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(values, values, Mod256(), std::allocator<int>());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h b/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
new file mode 100644
index 00000000000000..1f5d24c0e4eab7
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_NAIVE_STATIC_VECTOR_H
+#define SUPPORT_NAIVE_STATIC_VECTOR_H
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template<class T, size_t N>
+struct NaiveStaticVector {
+ struct CapacityError {};
+
+ using value_type = T;
+ using difference_type = short;
+ using size_type = unsigned short;
+ using iterator = random_access_iterator<T*>;
+ using const_iterator = random_access_iterator<const T*>;
+
+ explicit NaiveStaticVector() = default;
+ template<class It> explicit NaiveStaticVector(It first, It last) { while (first != last) insert(*first++); }
+
+ // Moving-from a NaiveStaticVector leaves the source vector holding moved-from objects.
+ // This is intentional (the "Naive" in the name).
+ // Specifically, moving-out-of a sorted+uniqued NaiveStaticVector<MoveOnly>
+ // will leave it in a non-sorted+uniqued state.
+
+ NaiveStaticVector(const NaiveStaticVector&) = default;
+ NaiveStaticVector(NaiveStaticVector&&) = default; // deliberately don't reset size_
+ NaiveStaticVector& operator=(const NaiveStaticVector&) = default;
+ NaiveStaticVector& operator=(NaiveStaticVector&&) = default;
+
+ iterator begin() { return iterator(data_); }
+ const_iterator begin() const { return const_iterator(data_); }
+ const_iterator cbegin() const { return const_iterator(data_); }
+ iterator end() { return begin() + size(); }
+ const_iterator end() const { return begin() + size(); }
+ size_type size() const { return size_; }
+ bool empty() const { return size_ == 0; }
+
+ void clear() { size_ = 0; }
+
+ template<class It>
+ iterator insert(const_iterator pos, It first, It last) {
+ iterator result = pos - cbegin() + begin();
+ while (first != last) {
+ insert(pos++, *first++);
+ }
+ return result;
+ }
+
+ iterator insert(const_iterator pos, T value) {
+ if (size_ == N) {
+ throw CapacityError();
+ }
+ int i = pos - cbegin();
+ size_ += 1;
+ std::move_backward(&data_[i], &data_[size_ - 1], &data_[size_]);
+ data_[i] = std::move(value);
+ return begin() + i;
+ }
+
+ template <class... Args>
+ iterator emplace(const_iterator pos, Args&&... args) {
+ return insert(pos, T(std::forward<Args>(args)...));
+ }
+
+ iterator erase(const_iterator first, const_iterator last) {
+ int i = first - cbegin();
+ int j = last - cbegin();
+ std::move(&data_[j], &data_[size_], &data_[i]);
+ size_ -= (last - first);
+ return begin() + i;
+ }
+
+ iterator erase(const_iterator pos) {
+ return erase(pos, std::next(pos));
+ }
+
+private:
+ T data_[N];
+ size_t size_ = 0;
+};
+
+#endif // SUPPORT_NAIVE_STATIC_VECTOR_H
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
new file mode 100644
index 00000000000000..ec0172347641d8
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// class flat_map
+
+// void clear() noexcept;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, int>;
+ M m = {{1,2}, {2,1}, {3,3}, {4,1}, {5,0}};
+ assert(m.size() == 5);
+ ASSERT_NOEXCEPT(m.clear());
+ ASSERT_SAME_TYPE(decltype(m.clear()), void);
+ m.clear();
+ assert(m.size() == 0);
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
+ M m = {{1,2}, {2,1}, {3,3}, {4,1}, {5,0}};
+ assert(m.size() == 5);
+ ASSERT_NOEXCEPT(m.clear());
+ ASSERT_SAME_TYPE(decltype(m.clear()), void);
+ m.clear();
+ assert(m.size() == 0);
+ }
+ {
+ using M = std::flat_map<bool, bool>;
+ M m = {{true,false}, {false,true}};
+ assert(m.size() == 2);
+ ASSERT_NOEXCEPT(m.clear());
+ ASSERT_SAME_TYPE(decltype(m.clear()), void);
+ m.clear();
+ assert(m.size() == 0);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
new file mode 100644
index 00000000000000..c1cf9307ce498a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// key_compare key_comp() const;
+// value_compare value_comp() const;
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, char>;
+ using Comp = std::less<int>; // the default
+ M m = {};
+ ASSERT_SAME_TYPE(M::key_compare, Comp);
+ static_assert(!std::is_same_v<M::value_compare, Comp>);
+ ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
+ ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
+ Comp kc = m.key_comp();
+ assert(kc(1, 2));
+ assert(!kc(2, 1));
+ auto vc = m.value_comp();
+ ASSERT_SAME_TYPE(decltype(vc(std::make_pair(1, 2), std::make_pair(1, 2))), bool);
+ assert(vc({1, '2'}, {2, '1'}));
+ assert(!vc({2, '1'}, {1, '2'}));
+ }
+ {
+ using Comp = std::function<bool(int, int)>;
+ using M = std::flat_map<int, int, Comp>;
+ Comp comp = std::greater<int>();
+ M m({}, comp);
+ ASSERT_SAME_TYPE(M::key_compare, Comp);
+ ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
+ ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
+ Comp kc = m.key_comp();
+ assert(!kc(1, 2));
+ assert(kc(2, 1));
+ auto vc = m.value_comp();
+ auto a = std::make_pair(1, 2);
+ ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
+ static_assert(!noexcept(vc(a, a)));
+ assert(!vc({1, 2}, {2, 1}));
+ assert(vc({2, 1}, {1, 2}));
+ }
+ {
+ using Comp = std::less<>;
+ using M = std::flat_map<int, int, Comp>;
+ M m = {};
+ ASSERT_SAME_TYPE(M::key_compare, Comp);
+ ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
+ ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
+ Comp kc = m.key_comp();
+ assert(kc(1, 2));
+ assert(!kc(2, 1));
+ auto vc = m.value_comp();
+ auto a = std::make_pair(1, 2);
+ ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
+ assert(vc({1, 2}, {2, 1}));
+ assert(!vc({2, 1}, {1, 2}));
+ }
+ {
+ using Comp = std::function<bool(const std::vector<int>&, const std::vector<int>&)>;
+ using M = std::flat_map<std::vector<int>, int, Comp>;
+ Comp comp = [i=1](const auto& x, const auto& y) { return x[i] < y[i]; };
+ M m({}, comp);
+ auto vc = m.value_comp();
+ static_assert(sizeof(vc) >= sizeof(Comp));
+ comp = nullptr;
+ m = M({}, nullptr);
+ assert(m.key_comp() == nullptr);
+ // At this point, m.key_comp() is disengaged.
+ // But the std::function captured by copy inside `vc` remains valid.
+ auto a = std::make_pair(std::vector<int>{2,1,4}, 42);
+ auto b = std::make_pair(std::vector<int>{1,2,3}, 42);
+ auto c = std::make_pair(std::vector<int>{0,3,2}, 42);
+ assert(vc(a, b));
+ assert(vc(b, c));
+ assert(!vc(b, a));
+ assert(!vc(c, b));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
new file mode 100644
index 00000000000000..5f1def4304cf11
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// bool contains(const key_type& x) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, const char*>;
+ M m = {{1,""}, {2,""}, {4,""}, {5,""}, {8,""}};
+ assert(!m.contains(0));
+ assert( m.contains(1));
+ assert( m.contains(2));
+ assert(!m.contains(3));
+ assert( m.contains(4));
+ assert( m.contains(5));
+ assert(!m.contains(6));
+ assert(!m.contains(7));
+ assert( std::as_const(m).contains(8));
+ assert(!std::as_const(m).contains(9));
+ m.clear();
+ assert(!m.contains(1));
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ M m = {{1,0}, {2,0}, {4,0}, {5,0}, {8,0}};
+ assert(!m.contains(0));
+ assert( m.contains(1));
+ assert( m.contains(2));
+ assert(!m.contains(3));
+ assert( m.contains(4));
+ assert( m.contains(5));
+ assert(!m.contains(6));
+ assert(!m.contains(7));
+ assert( std::as_const(m).contains(8));
+ assert(!std::as_const(m).contains(9));
+ m.clear();
+ assert(!m.contains(1));
+ }
+ {
+ using M = std::flat_map<bool, int>;
+ M m = {{true,1}, {false,2}};
+ assert( m.contains(true));
+ assert( m.contains(false));
+ m = {{true,3}};
+ assert( m.contains(true));
+ assert(!m.contains(false));
+ m = {{false,4}};
+ assert(!std::as_const(m).contains(true));
+ assert( std::as_const(m).contains(false));
+ m.clear();
+ assert(!m.contains(true));
+ assert(!m.contains(false));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
new file mode 100644
index 00000000000000..0c4c9fcefad8a0
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> bool contains(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.contains(StartsWith('b'))), bool);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(StartsWith('b'))), bool);
+ assert(m.contains("beta") == true);
+ assert(m.contains("delta") == false);
+ assert(m.contains("zeta") == false);
+ assert(m.contains(StartsWith('b')) == true);
+ assert(m.contains(StartsWith('d')) == false);
+ assert(m.contains(StartsWith('e')) == true);
+ assert(m.contains(StartsWith('z')) == false);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
new file mode 100644
index 00000000000000..bca4251bdb36bb
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// size_type count(const key_type& x) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, const char*>;
+ M m = {{1,""}, {2,""}, {4,""}, {5,""}, {8,""}};
+ ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
+ assert(m.count(0) == 0);
+ assert(m.count(1) == 1);
+ assert(m.count(2) == 1);
+ assert(m.count(3) == 0);
+ assert(m.count(4) == 1);
+ assert(m.count(5) == 1);
+ assert(m.count(6) == 0);
+ assert(m.count(7) == 0);
+ assert(std::as_const(m).count(8) == 1);
+ assert(std::as_const(m).count(9) == 0);
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ M m = {{1,0}, {2,0}, {4,0}, {5,0}, {8,0}};
+ ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
+ assert(m.count(0) == 0);
+ assert(m.count(1) == 1);
+ assert(m.count(2) == 1);
+ assert(m.count(3) == 0);
+ assert(m.count(4) == 1);
+ assert(m.count(5) == 1);
+ assert(m.count(6) == 0);
+ assert(m.count(7) == 0);
+ assert(std::as_const(m).count(8) == 1);
+ assert(std::as_const(m).count(9) == 0);
+ }
+ {
+ using M = std::flat_map<bool, int>;
+ M m = {{true,1}, {false,2}};
+ ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
+ assert(m.count(true) == 1);
+ assert(m.count(false) == 1);
+ m = {{true,3}};
+ assert(m.count(true) == 1);
+ assert(m.count(false) == 0);
+ m = {{false,4}};
+ assert(std::as_const(m).count(true) == 0);
+ assert(std::as_const(m).count(false) == 1);
+ m.clear();
+ assert(m.count(true) == 0);
+ assert(m.count(false) == 0);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
new file mode 100644
index 00000000000000..2ca6bd9ec15ded
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> size_type count(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.count(StartsWith('b'))), M::size_type);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).count(StartsWith('b'))), M::size_type);
+ assert(m.count("beta") == 1);
+ assert(m.count("delta") == 0);
+ assert(m.count("zeta") == 0);
+ assert(m.count(StartsWith('b')) == 1);
+ assert(m.count(StartsWith('d')) == 0);
+ assert(m.count(StartsWith('e')) == 2);
+ assert(m.count(StartsWith('z')) == 0);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
new file mode 100644
index 00000000000000..000b36daa9988e
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// [[nodiscard]] bool empty() const noexcept;
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ typedef std::flat_map<int, int> M;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.empty()), bool);
+ ASSERT_NOEXCEPT(m.empty());
+ assert(m.empty());
+ assert(std::as_const(m).empty());
+ m = {{1, 1}};
+ assert(!m.empty());
+ m.clear();
+ assert(m.empty());
+ }
+ {
+ typedef std::flat_map<int, int, std::less<int>, std::deque<int, min_allocator<int>>> M;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.empty()), bool);
+ ASSERT_NOEXCEPT(m.empty());
+ assert(m.empty());
+ assert(std::as_const(m).empty());
+ m = {{1, 1}};
+ assert(!m.empty());
+ m.clear();
+ assert(m.empty());
+ }
+ {
+ typedef std::flat_map<bool, bool> M;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.empty()), bool);
+ ASSERT_NOEXCEPT(m.empty());
+ assert(m.empty());
+ assert(std::as_const(m).empty());
+ m = {{false, false}};
+ assert(!m.empty());
+ m.clear();
+ assert(m.empty());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
new file mode 100644
index 00000000000000..8d98abf10ad645
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// [[nodiscard]] bool empty() const noexcept;
+
+#include <flat_map>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ std::flat_map<int, int> c;
+ c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
new file mode 100644
index 00000000000000..6d1c3fd4d38d72
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// pair<iterator,iterator> equal_range(const key_type& k);
+// pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ using R = std::pair<M::iterator, M::iterator>;
+ using CR = std::pair<M::const_iterator, M::const_iterator>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
+ auto begin = m.begin();
+ assert(m.equal_range(0) == std::pair(begin, begin));
+ assert(m.equal_range(1) == std::pair(begin, begin+1));
+ assert(m.equal_range(2) == std::pair(begin+1, begin+2));
+ assert(m.equal_range(3) == std::pair(begin+2, begin+2));
+ assert(m.equal_range(4) == std::pair(begin+2, begin+3));
+ assert(m.equal_range(5) == std::pair(begin+3, begin+4));
+ assert(m.equal_range(6) == std::pair(begin+4, begin+4));
+ assert(m.equal_range(7) == std::pair(begin+4, begin+4));
+ assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin()+4, m.cbegin()+5));
+ assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin()+5, m.cbegin()+5));
+ }
+ {
+ using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
+ using R = std::pair<M::iterator, M::iterator>;
+ using CR = std::pair<M::const_iterator, M::const_iterator>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
+ auto begin = m.begin();
+ assert(m.equal_range(0) == std::pair(begin+5, begin+5));
+ assert(m.equal_range(1) == std::pair(begin+4, begin+5));
+ assert(m.equal_range(2) == std::pair(begin+3, begin+4));
+ assert(m.equal_range(3) == std::pair(begin+3, begin+3));
+ assert(m.equal_range(4) == std::pair(begin+2, begin+3));
+ assert(m.equal_range(5) == std::pair(begin+1, begin+2));
+ assert(m.equal_range(6) == std::pair(begin+1, begin+1));
+ assert(m.equal_range(7) == std::pair(begin+1, begin+1));
+ assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin()+1));
+ assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin()));
+ }
+ {
+ using M = std::flat_map<bool, bool>;
+ using R = std::pair<M::iterator, M::iterator>;
+ using CR = std::pair<M::const_iterator, M::const_iterator>;
+ M m = {{true,false}, {false,true}};
+ ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
+ assert(m.equal_range(true) == std::pair(m.begin()+1, m.end()));
+ assert(m.equal_range(false) == std::pair(m.begin(), m.begin()+1));
+ m = {{true,true}};
+ assert(m.equal_range(true) == std::pair(m.begin(), m.end()));
+ assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
+ m = {{false,false}};
+ assert(std::as_const(m).equal_range(true) == std::pair(m.cend(), m.cend()));
+ assert(std::as_const(m).equal_range(false) == std::pair(m.cbegin(), m.cend()));
+ m.clear();
+ assert(m.equal_range(true) == std::pair(m.begin(), m.begin()));
+ assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
new file mode 100644
index 00000000000000..ee6bc7ef8868f9
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> pair<iterator,iterator> equal_range(const K& x);
+// template<class K> pair<const_iterator,const_iterator> equal_range(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ using R = std::pair<M::iterator, M::iterator>;
+ using CR = std::pair<M::const_iterator, M::const_iterator>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.equal_range(StartsWith('b'))), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(StartsWith('b'))), CR);
+ auto begin = m.begin();
+ assert(m.equal_range("beta") == std::pair(begin+1, begin+2));
+ assert(m.equal_range("delta") == std::pair(begin+2, begin+2));
+ assert(m.equal_range("zeta") == std::pair(begin+5, begin+5));
+ assert(m.equal_range(StartsWith('b')) == std::pair(begin+1, begin+2));
+ assert(m.equal_range(StartsWith('d')) == std::pair(begin+2, begin+2));
+ assert(m.equal_range(StartsWith('e')) == std::pair(begin+2, begin+4));
+ assert(m.equal_range(StartsWith('z')) == std::pair(begin+5, begin+5));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
new file mode 100644
index 00000000000000..8b76882138921a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// size_type erase(const key_type& k);
+
+#include <compare>
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ auto make = [](std::initializer_list<int> il) {
+ M m;
+ for (int i : il) {
+ m.emplace(i, i);
+ }
+ return m;
+ };
+ M m = make({1,2,3,4,5,6,7,8});
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
+ auto n = m.erase(9);
+ assert(n == 0);
+ assert(m == make({1,2,3,4,5,6,7,8}));
+ n = m.erase(4);
+ assert(n == 1);
+ assert(m == make({1,2,3,5,6,7,8}));
+ n = m.erase(1);
+ assert(n == 1);
+ assert(m == make({2,3,5,6,7,8}));
+ n = m.erase(8);
+ assert(n == 1);
+ assert(m == make({2,3,5,6,7}));
+ n = m.erase(3);
+ assert(n == 1);
+ assert(m == make({2,5,6,7}));
+ n = m.erase(4);
+ assert(n == 0);
+ assert(m == make({2,5,6,7}));
+ n = m.erase(6);
+ assert(n == 1);
+ assert(m == make({2,5,7}));
+ n = m.erase(7);
+ assert(n == 1);
+ assert(m == make({2,5}));
+ n = m.erase(2);
+ assert(n == 1);
+ assert(m == make({5}));
+ n = m.erase(5);
+ assert(n == 1);
+ assert(m.empty());
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
+ auto make = [](std::initializer_list<int> il) {
+ M m;
+ for (int i : il) {
+ m.emplace(i, i);
+ }
+ return m;
+ };
+ M::key_container_type container = {5,6,7,8};
+ container.insert(container.begin(), {1,2,3,4});
+ M m = M(std::move(container), {1,2,3,4,5,6,7,8});
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
+ auto n = m.erase(9);
+ assert(n == 0);
+ assert(m == make({1,2,3,4,5,6,7,8}));
+ n = m.erase(4);
+ assert(n == 1);
+ assert(m == make({1,2,3,5,6,7,8}));
+ n = m.erase(1);
+ assert(n == 1);
+ assert(m == make({2,3,5,6,7,8}));
+ n = m.erase(8);
+ assert(n == 1);
+ assert(m == make({2,3,5,6,7}));
+ n = m.erase(3);
+ assert(n == 1);
+ assert(m == make({2,5,6,7}));
+ n = m.erase(4);
+ assert(n == 0);
+ assert(m == make({2,5,6,7}));
+ n = m.erase(6);
+ assert(n == 1);
+ assert(m == make({2,5,7}));
+ n = m.erase(7);
+ assert(n == 1);
+ assert(m == make({2,5}));
+ n = m.erase(2);
+ assert(n == 1);
+ assert(m == make({5}));
+ n = m.erase(5);
+ assert(n == 1);
+ assert(m.empty());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
new file mode 100644
index 00000000000000..cad13d18f1fec2
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
@@ -0,0 +1,119 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// size_type erase(K&& k);
+
+#include <compare>
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template<class Key, class It>
+struct HeterogeneousKey {
+ explicit HeterogeneousKey(Key key, It it) : key_(key), it_(it) {}
+ operator It() && { return it_; }
+ auto operator<=>(Key key) const { return key_ <=> key; }
+ Key key_;
+ It it_;
+};
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.erase(StartsWith('b'))), M::size_type);
+ M::size_type n = m.erase(StartsWith('e'));
+ assert(n == 2);
+ assert((m == M{ {"alpha", 1}, {"beta", 2}, {"gamma", 5} }));
+ n = m.erase(StartsWith('d'));
+ assert(n == 0);
+ assert((m == M{ {"alpha", 1}, {"beta", 2}, {"gamma", 5} }));
+ }
+ {
+ using M = std::flat_map<int, int, std::less<>>;
+ M m = {{1,1}, {2,2}, {3,3}, {4,4}};
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
+ auto n = m.erase(3); // erase(K&&) [with K=int]
+ assert(n == 1);
+ assert((m == M{{1,1}, {2,2}, {4,4}}));
+ M::key_type lvalue = 2;
+ n = m.erase(lvalue); // erase(K&&) [with K=int&]
+ assert(n == 1);
+ assert((m == M{{1,1}, {4,4}}));
+ const M::key_type const_lvalue = 1;
+ n = m.erase(const_lvalue); // erase(const key_type&)
+ assert(n == 1);
+ assert((m == M{{4,4}}));
+ }
+ {
+ using M = std::flat_map<int, int, std::less<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
+ M m = {{1,1}, {2,2}, {3,3}, {4,4}};
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
+ auto n = m.erase(3); // erase(K&&) [with K=int]
+ assert(n == 1);
+ assert((m == M{{1,1}, {2,2}, {4,4}}));
+ M::key_type lvalue = 2;
+ n = m.erase(lvalue); // erase(K&&) [with K=int&]
+ assert(n == 1);
+ assert((m == M{{1,1}, {4,4}}));
+ const M::key_type const_lvalue = 1;
+ n = m.erase(const_lvalue); // erase(const key_type&)
+ assert(n == 1);
+ assert((m == M{{4,4}}));
+ }
+ {
+ // P2077's HeterogeneousKey example
+ using M = std::flat_map<int, int, std::less<>>;
+ M m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
+ auto h1 = HeterogeneousKey<int, M::iterator>(8, m.begin());
+ std::same_as<M::size_type> auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match
+ assert(n == 1);
+ assert((m == M{{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ std::same_as<M::iterator> auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out
+ assert(it == m.begin());
+ assert((m == M{{2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ }
+ {
+ using M = std::flat_map<int, int, std::less<>>;
+ M m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
+ auto h1 = HeterogeneousKey<int, M::const_iterator>(8, m.begin());
+ std::same_as<M::size_type> auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match
+ assert(n == 1);
+ assert((m == M{{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ std::same_as<M::iterator> auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out
+ assert(it == m.begin());
+ assert((m == M{{2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
new file mode 100644
index 00000000000000..4f3f4a832d5575
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator find(const key_type& k);
+// const_iterator find(const key_type& k) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
+ assert(m.find(0) == m.end());
+ assert(m.find(1) == m.begin());
+ assert(m.find(2) == m.begin() + 1);
+ assert(m.find(3) == m.end());
+ assert(m.find(4) == m.begin() + 2);
+ assert(m.find(5) == m.begin() + 3);
+ assert(m.find(6) == m.end());
+ assert(m.find(7) == m.end());
+ assert(std::as_const(m).find(8) == m.begin() + 4);
+ assert(std::as_const(m).find(9) == m.end());
+ }
+ {
+ using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::string>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
+ assert(m.find(0) == m.end());
+ assert(m.find(1) == m.begin() + 4);
+ assert(m.find(2) == m.begin() + 3);
+ assert(m.find(3) == m.end());
+ assert(m.find(4) == m.begin() + 2);
+ assert(m.find(5) == m.begin() + 1);
+ assert(m.find(6) == m.end());
+ assert(m.find(7) == m.end());
+ assert(std::as_const(m).find(8) == m.begin());
+ assert(std::as_const(m).find(9) == m.end());
+ }
+ {
+ using M = std::flat_map<bool, bool>;
+ M m = {{true,false}, {false,true}};
+ ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
+ assert(m.find(true) == m.begin() + 1);
+ assert(m.find(false) == m.begin());
+ m = {{true,true}};
+ assert(m.find(true) == m.begin());
+ assert(m.find(false) == m.end());
+ m = {{false,false}};
+ assert(std::as_const(m).find(true) == m.end());
+ assert(std::as_const(m).find(false) == m.begin());
+ m.clear();
+ assert(m.find(true) == m.end());
+ assert(m.find(false) == m.end());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
new file mode 100644
index 00000000000000..860959ed4f01be
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator find(const K& x);
+// template<class K> const_iterator find(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.find(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(StartsWith('b'))), M::const_iterator);
+ assert(m.find("beta") == m.begin() + 1);
+ assert(m.find("delta") == m.end());
+ assert(m.find("zeta") == m.end());
+ assert(m.find(StartsWith('b')) == m.begin() + 1);
+ assert(m.find(StartsWith('d')) == m.end());
+ auto it = m.find(StartsWith('e'));
+ assert(m.begin() + 2 <= it && it <= m.begin() + 3); // either is acceptable
+ LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
+ assert(m.find(StartsWith('z')) == m.end());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
new file mode 100644
index 00000000000000..cbfefa8a66b494
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class Allocator>
+// explicit flat_map(const Allocator& a);
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using A = test_allocator<short>;
+ using M = std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>;
+ M m(A(0, 5));
+ assert(m.empty());
+ assert(m.begin() == m.end());
+ assert(m.keys().get_allocator().get_id() == 5);
+ assert(m.values().get_allocator().get_id() == 5);
+ }
+ {
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::polymorphic_allocator<int> pa = &mr;
+ auto m1 = M(pa);
+ assert(m1.empty());
+ assert(m1.keys().get_allocator() == pa);
+ assert(m1.values().get_allocator() == pa);
+ auto m2 = M(&mr);
+ assert(m2.empty());
+ assert(m2.keys().get_allocator() == pa);
+ assert(m2.values().get_allocator() == pa);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
new file mode 100644
index 00000000000000..91e969b8e10001
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(initializer_list<value_type> il);
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <ranges>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+
+int main(int, char**) {
+ {
+ using C = std::flat_map<int, int>;
+ C m = {{8,8}, {10,10}};
+ assert(m.size() == 2);
+ m = {{3,0}, {1,0}, {2,0}, {2,1}, {3,1}, {4,0}, {3,2}, {5,0}, {6,0}, {5,1}};
+ std::pair<int, int> expected[] = {{1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}};
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ }
+ {
+ using C = std::flat_map<int, int, std::less<>, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
+ C m = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}};
+ assert(m.size() == 10);
+ m = {{1,1}, {3,2}, {4,3}, {5,4}, {6,5}, {5,6}, {2,7}};
+ std::pair<int, int> expected[] = {{1,1}, {2,7}, {3,2}, {4,3}, {5,4}, {6,5}};
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ }
+ {
+ using C = std::flat_map<double, int, std::less<>, std::deque<double, min_allocator<double>>, std::vector<int, min_allocator<int>>>;
+ C m = {};
+ assert(m.size() == 0);
+ m = {{3,0}, {1,0}, {2,0}, {2,1}, {3,1}, {4,0}, {3,2}, {5,0}, {6,0}, {5,1}};
+ std::pair<double, int> expected[] = {{1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}};
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ }
+ {
+ using C = std::flat_map<double, double, std::less<>, std::deque<double>, std::deque<double>>;
+ C m = {{10,1}, {8,1}};
+ assert(m.size() == 2);
+ m = {{3,2}};
+ std::pair<double, double> expected[] = {{3,2}};
+ assert(std::ranges::equal(m, expected));
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
new file mode 100644
index 00000000000000..445095742bbae5
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// explicit flat_map(const key_compare& comp);
+// template <class Alloc>
+// flat_map(const key_compare& comp, const Alloc& a);
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = test_less<int>;
+ auto m = std::flat_map<int, char*, C>(C(3));
+ assert(m.empty());
+ assert(m.begin() == m.end());
+ assert(m.key_comp() == C(3));
+ }
+ {
+ // The one-argument ctor is explicit.
+ using C = test_less<int>;
+ static_assert(std::is_constructible_v<std::flat_map<int, char*, C>, C>);
+ static_assert(!std::is_convertible_v<C, std::flat_map<int, char*, C>>);
+
+ static_assert(std::is_constructible_v<std::flat_map<int, char*>, std::less<int>>);
+ static_assert(!std::is_convertible_v<std::less<int>, std::flat_map<int, char*>>);
+ }
+ {
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ auto m = std::flat_map<int, short, C, std::vector<int, A1>, std::vector<short, A2>>(C(4), A1(5));
+ assert(m.empty());
+ assert(m.begin() == m.end());
+ assert(m.key_comp() == C(4));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ std::flat_map<int, short, C, std::deque<int, A1>, std::deque<short, A2>> m = { C(4), A1(5) }; // implicit ctor
+ assert(m.empty());
+ assert(m.begin() == m.end());
+ assert(m.key_comp() == C(4));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using M = std::flat_map<int, int, std::function<bool(int, int)>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::greater<int>());
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp()(2, 1) == true);
+ assert(vm[0].value_comp()({2, 0}, {1, 0}) == true);
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // If an allocator is given, it must be usable by both containers.
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, std::vector<int, A>>;
+ static_assert(std::is_constructible_v<M, std::less<>>);
+ static_assert(!std::is_constructible_v<M, std::less<>, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, std::less<>, A>);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
new file mode 100644
index 00000000000000..0c8d414c9da7c0
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
@@ -0,0 +1,228 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
+// const key_compare& comp = key_compare());
+// template<class Allocator>
+// flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+// const Allocator& a);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+struct P {
+ int first;
+ int second;
+ template<class T, class U>
+ bool operator==(const std::pair<T, U>& rhs) const {
+ return MoveOnly(first) == rhs.first && MoveOnly(second) == rhs.second;
+ }
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ std::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::vector<char> vs = {1,2,3,4,5,6,7,8,9};
+ auto m = M(ks, vs);
+ assert((m.keys() == std::vector<int>{1,2,3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ m = M(std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m.keys() == std::vector<int>{1,2,3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ }
+ {
+ P expected[] = {{3,2}, {2,1}, {1,3}};
+ using Ks = std::deque<int, min_allocator<int>>;
+ using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
+ using M = std::flat_map<int, MoveOnly, std::greater<int>, Ks, Vs>;
+ Ks ks = {1,3,2};
+ Vs vs;
+ vs.push_back(3);
+ vs.push_back(2);
+ vs.push_back(1);
+ auto m = M(std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert(std::ranges::equal(m, expected, std::equal_to<>()));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ auto m = M(std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.keys().get_allocator() == A(5));
+ assert(m.values().get_allocator() == A(6));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ auto m = M(ks, vs, A(4)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.keys().get_allocator() == A(4));
+ assert(m.values().get_allocator() == A(4));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ M m = { ks, vs, A(4) }; // implicit ctor
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.keys().get_allocator() == A(4));
+ assert(m.values().get_allocator() == A(4));
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ assert(ks.get_allocator().resource() != &mr);
+ assert(vs.get_allocator().resource() != &mr);
+ vm.emplace_back(ks, vs);
+ assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
+ assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
+ assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ assert(ks.get_allocator().resource() != &mr);
+ assert(vs.get_allocator().resource() != &mr);
+ vm.emplace_back(std::move(ks), std::move(vs));
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+
+#if 0
+ // Test all combinations of lvalue and rvalue containers (LWG 3802).
+ {
+ int input[] = {1,1,1,2,2,3,2,3,3};
+ const P expected[] = {{1,1}, {2,2}, {3,3}};
+ {
+ using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks(input, input + 9);
+ std::pmr::vector<MoveOnly> vs(input, input + 9);
+ vm.emplace_back(ks, std::move(vs)); // ill-formed before LWG 3802
+ assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 9);
+ std::pmr::vector<int> vs(input, input + 9);
+ vm.emplace_back(std::move(ks), vs); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 9);
+ std::pmr::vector<MoveOnly> vs(input, input + 9);
+ vm.emplace_back(std::move(ks), std::move(vs)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ {
+ int input[] = {1,2,3};
+ const P expected[] = {{1,1}, {2,2}, {3,3}};
+ {
+ using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks(input, input + 3);
+ std::pmr::vector<MoveOnly> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, ks, std::move(vs)); // ill-formed before LWG 3802
+ assert(ks.size() == 3); // ks' value is unchanged, since it was an lvalue above
+ LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 3);
+ std::pmr::vector<int> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, std::move(ks), vs); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
+ assert(vs.size() == 3); // vs' value is unchanged, since it was an lvalue above
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 3);
+ std::pmr::vector<MoveOnly> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ #endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
new file mode 100644
index 00000000000000..e26f0162802ea5
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
@@ -0,0 +1,246 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
+// const key_compare& comp = key_compare());
+// template<class Allocator>
+// flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+// const Allocator& a);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../../../test_compare.h"
+
+struct P {
+ int first;
+ int second;
+ template<class T, class U>
+ bool operator==(const std::pair<T, U>& rhs) const {
+ return MoveOnly(first) == rhs.first && MoveOnly(second) == rhs.second;
+ }
+};
+
+int main(int, char**)
+{
+ using C = test_less<int>;
+ {
+ using M = std::flat_map<int, char, C>;
+ std::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::vector<char> vs = {1,2,3,4,5,6,7,8,9};
+ auto m = M(ks, vs, C(2));
+ assert((m.keys() == std::vector<int>{1,2,3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ assert(m.key_comp() == C(2));
+ m = M(std::move(ks), std::move(vs), C(3));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m.keys() == std::vector<int>{1,2,3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ assert(m.key_comp() == C(3));
+ }
+ {
+ P expected[] = {{1,3}, {2,1}, {3,2}};
+ using Ks = std::deque<int, min_allocator<int>>;
+ using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
+ using M = std::flat_map<int, MoveOnly, C, Ks, Vs>;
+ Ks ks = {1,3,2};
+ Vs vs;
+ vs.push_back(3);
+ vs.push_back(2);
+ vs.push_back(1);
+ auto m = M(std::move(ks), std::move(vs), C(2));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert(std::ranges::equal(m, expected, std::equal_to<>()));
+ assert(m.key_comp() == C(2));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ auto m = M(std::move(ks), std::move(vs), C(2));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.key_comp() == C(2));
+ assert(m.keys().get_allocator() == A(5));
+ assert(m.values().get_allocator() == A(6));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ auto m = M(ks, vs, C(2), A(4)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.key_comp() == C(2));
+ assert(m.keys().get_allocator() == A(4));
+ assert(m.values().get_allocator() == A(4));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
+ auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
+ M m = { ks, vs, C(2), A(4) }; // implicit ctor
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.key_comp() == C(2));
+ assert(m.keys().get_allocator() == A(4));
+ assert(m.values().get_allocator() == A(4));
+ }
+ {
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ assert(ks.get_allocator().resource() != &mr);
+ assert(vs.get_allocator().resource() != &mr);
+ vm.emplace_back(ks, vs, C(2));
+ assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
+ assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
+ assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert(vm[0].key_comp() == C(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ assert(ks.get_allocator().resource() != &mr);
+ assert(vs.get_allocator().resource() != &mr);
+ vm.emplace_back(std::move(ks), std::move(vs), C(2));
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert(vm[0].key_comp() == C(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+
+#if 0
+ // Test all combinations of lvalue and rvalue containers (LWG 3802).
+ {
+ using C2 = test_less<MoveOnly>;
+ int input[] = {1,1,1,2,2,3,2,3,3};
+ const P expected[] = {{1,1}, {2,2}, {3,3}};
+ {
+ using M = std::flat_map<int, MoveOnly, C, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks(input, input + 9);
+ std::pmr::vector<MoveOnly> vs(input, input + 9);
+ vm.emplace_back(ks, std::move(vs), C(2)); // ill-formed before LWG 3802
+ assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, int, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 9);
+ std::pmr::vector<int> vs(input, input + 9);
+ vm.emplace_back(std::move(ks), vs, C2(2)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C2(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, MoveOnly, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 9);
+ std::pmr::vector<MoveOnly> vs(input, input + 9);
+ vm.emplace_back(std::move(ks), std::move(vs), C2(2)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C2(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ {
+ using C2 = test_less<MoveOnly>;
+ int input[] = {1,2,3};
+ const P expected[] = {{1,1}, {2,2}, {3,3}};
+ {
+ using M = std::flat_map<int, MoveOnly, C, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks(input, input + 3);
+ std::pmr::vector<MoveOnly> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, ks, std::move(vs), C(2)); // ill-formed before LWG 3802
+ assert(ks.size() == 3); // ks' value is unchanged, since it was an lvalue above
+ LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, int, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 3);
+ std::pmr::vector<int> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, std::move(ks), vs, C2(2)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
+ assert(vs.size() == 3); // vs' value is unchanged, since it was an lvalue above
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C2(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, MoveOnly, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<MoveOnly> ks(input, input + 3);
+ std::pmr::vector<MoveOnly> vs(input, input + 3);
+ vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs), C2(2)); // ill-formed before LWG 3802
+ LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
+ assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
+ assert(vm[0].key_comp() == C2(2));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ #endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
new file mode 100644
index 00000000000000..bc1d713abb74d3
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(const flat_map& m);
+
+#include <cassert>
+#include <flat_map>
+#include <memory_resource>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = test_less<int>;
+ std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
+ std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
+ using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
+ auto mo = M(ks, vs, C(5));
+ auto m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert(m.keys() == ks);
+ assert(m.values() == vs);
+ assert(m.keys().get_allocator() == test_allocator<int>(6));
+ assert(m.values().get_allocator() == test_allocator<char>(7));
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys() == ks);
+ assert(mo.values() == vs);
+ assert(mo.keys().get_allocator() == test_allocator<int>(6));
+ assert(mo.values().get_allocator() == test_allocator<char>(7));
+ }
+ {
+ using C = test_less<int>;
+ using Ks = std::vector<int, other_allocator<int>>;
+ using Vs = std::vector<char, other_allocator<char>>;
+ auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
+ auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
+ using M = std::flat_map<int, char, C, Ks, Vs>;
+ auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
+ auto m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert(m.keys() == ks);
+ assert(m.values() == vs);
+ assert(m.keys().get_allocator() == other_allocator<int>(-2));
+ assert(m.values().get_allocator() == other_allocator<char>(-2));
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys() == ks);
+ assert(mo.values() == vs);
+ assert(mo.keys().get_allocator() == other_allocator<int>(6));
+ assert(mo.values().get_allocator() == other_allocator<char>(7));
+ }
+ {
+ using C = test_less<int>;
+ std::pmr::monotonic_buffer_resource mr;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ auto mo = M({{1,1}, {2,2}, {3,3}}, C(5), &mr);
+ auto m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ auto [ks, vs] = std::move(m).extract();
+ assert(ks.get_allocator().resource() == std::pmr::get_default_resource());
+ assert(vs.get_allocator().resource() == std::pmr::get_default_resource());
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert((mo == M{{1,1}, {2,2}, {3,3}}));
+ auto [kso, vso] = std::move(mo).extract();
+ assert(kso.get_allocator().resource() == &mr);
+ assert(vso.get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
new file mode 100644
index 00000000000000..a7ff983a2219ce
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(const flat_map&, const allocator_type&);
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = test_less<int>;
+ std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
+ std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
+ using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
+ auto mo = M(ks, vs, C(5));
+ auto m = M(mo, test_allocator<int>(3));
+
+ assert(m.key_comp() == C(5));
+ assert(m.keys() == ks);
+ assert(m.values() == vs);
+ assert(m.keys().get_allocator() == test_allocator<int>(3));
+ assert(m.values().get_allocator() == test_allocator<char>(3));
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys() == ks);
+ assert(mo.values() == vs);
+ assert(mo.keys().get_allocator() == test_allocator<int>(6));
+ assert(mo.values().get_allocator() == test_allocator<char>(7));
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({1,2,3}, {2,2,1}, C(5), &mr1);
+ M m = {mo, &mr2}; // also test the implicitness of this constructor
+
+ assert(m.key_comp() == C(5));
+ assert((m.keys() == std::pmr::vector<int>{1,2,3}));
+ assert((m.values() == std::pmr::vector<int>{2,2,1}));
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert((mo.keys() == std::pmr::vector<int>{1,2,3}));
+ assert((mo.values() == std::pmr::vector<int>{2,2,1}));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ assert(mo.values().get_allocator().resource() == &mr1);
+ }
+ {
+ using M = std::flat_map<int, int, std::less<>, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::vector<M> vs;
+ M m = {{1,2}, {2,2}, {3,1}};
+ vs.push_back(m);
+ assert(vs[0] == m);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp
new file mode 100644
index 00000000000000..e9b752d5eb12b0
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(const flat_map& s);
+
+// Validate whether the container can be copy-assigned (move-assigned, swapped)
+// with an ADL-hijacking operator&
+
+#include <flat_map>
+#include <utility>
+
+#include "test_macros.h"
+#include "operator_hijacker.h"
+
+void test() {
+ std::flat_map<operator_hijacker, operator_hijacker> so;
+ std::flat_map<operator_hijacker, operator_hijacker> s;
+ s = so;
+ s = std::move(so);
+ swap(s, so);
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
new file mode 100644
index 00000000000000..9b78fbd7a786c3
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(const flat_map& m);
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ // test_allocator is not propagated
+ using C = test_less<int>;
+ std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
+ std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
+ using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
+ auto mo = M(ks, vs, C(5));
+ auto m = M({{3,3}, {4,4}, {5,5}}, C(3), test_allocator<int>(2));
+ m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert(m.keys() == ks);
+ assert(m.values() == vs);
+ assert(m.keys().get_allocator() == test_allocator<int>(2));
+ assert(m.values().get_allocator() == test_allocator<char>(2));
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys() == ks);
+ assert(mo.values() == vs);
+ assert(mo.keys().get_allocator() == test_allocator<int>(6));
+ assert(mo.values().get_allocator() == test_allocator<char>(7));
+ }
+ {
+ // other_allocator is propagated
+ using C = test_less<int>;
+ using Ks = std::vector<int, other_allocator<int>>;
+ using Vs = std::vector<char, other_allocator<char>>;
+ auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
+ auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
+ using M = std::flat_map<int, char, C, Ks, Vs>;
+ auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
+ auto m = M({{3,3}, {4,4}, {5,5}}, C(3), other_allocator<int>(2));
+ m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert(m.keys() == ks);
+ assert(m.values() == vs);
+ assert(m.keys().get_allocator() == other_allocator<int>(6));
+ assert(m.values().get_allocator() == other_allocator<char>(7));
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys() == ks);
+ assert(mo.values() == vs);
+ assert(mo.keys().get_allocator() == other_allocator<int>(6));
+ assert(mo.values().get_allocator() == other_allocator<char>(7));
+ }
+ {
+ // pmr allocator is not propagated
+ using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{1,1}, {2,2}, {3,3}}, &mr1);
+ M m = M({{4,4}, {5,5}}, &mr2);
+ m = mo;
+ assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+
+ // mo is unchanged
+ assert((mo == M{{1,1}, {2,2}, {3,3}}));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ }
+ {
+ // comparator is copied and invariant is preserved
+ using M = std::flat_map<int, int, std::function<bool(int, int)>>;
+ M mo = M({{1,2}, {3,4}}, std::less<int>());
+ M m = M({{1,2}, {3,4}}, std::greater<int>());
+ assert(m.key_comp()(2, 1) == true);
+ assert(m != mo);
+ m = mo;
+ assert(m.key_comp()(2, 1) == false);
+ assert(m == mo);
+ }
+ {
+ // self-assignment
+ using M = std::flat_map<int, int>;
+ M m = {{1,2}, {3,4}};
+ m = static_cast<const M&>(m);
+ assert((m == M{{1,2}, {3,4}}));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
new file mode 100644
index 00000000000000..56558bdf2e5f55
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -0,0 +1,489 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+#include <algorithm>
+#include <cassert>
+#include <climits>
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "deduction_guides_sfinae_checks.h"
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+void test_copy() {
+ {
+ std::flat_map<long, short> source = {{1,2}, {2,3}};
+ std::flat_map s(source);
+ ASSERT_SAME_TYPE(decltype(s), decltype(source));
+ assert(s == source);
+ }
+ {
+ std::flat_map<long, short, std::greater<long>> source = {{1,2}, {2,3}};
+ std::flat_map s{ source }; // braces instead of parens
+ ASSERT_SAME_TYPE(decltype(s), decltype(source));
+ assert(s == source);
+ }
+ {
+ std::flat_map<long, short, std::greater<long>> source = {{1,2}, {2,3}};
+ std::flat_map s(source, std::allocator<int>());
+ ASSERT_SAME_TYPE(decltype(s), decltype(source));
+ assert(s == source);
+ }
+}
+
+void test_containers() {
+ std::deque<int, test_allocator<int>> ks({ 1, 2, 1, INT_MAX, 3 }, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({ 1, 2, 1, 4, 5 }, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({ 1, 2, 3, INT_MAX }, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({ 1, 2, 5, 4 }, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {
+ {1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}
+ };
+ {
+ std::flat_map s(ks, vs);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 43);
+ }
+ {
+ std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 43);
+ }
+ {
+ std::flat_map s(ks, vs, test_allocator<long>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 44);
+ assert(s.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, test_allocator<long>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 44);
+ assert(s.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
+ std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
+ std::flat_map s(std::move(pks), std::move(pvs), &mr2);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
+ std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
+ std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+}
+
+void test_containers_compare() {
+ std::deque<int, test_allocator<int>> ks({ 1, 2, 1, INT_MAX, 3 }, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({ 1, 2, 1, 4, 5 }, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({ INT_MAX, 3, 2, 1 }, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({ 4, 5, 2, 1 }, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {
+ {INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}
+ };
+ {
+ std::flat_map s(ks, vs, std::greater<int>());
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 43);
+ }
+ {
+ std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>());
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 43);
+ }
+ {
+ std::flat_map s(ks, vs, std::greater<int>(), test_allocator<long>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 44);
+ assert(s.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>(), test_allocator<long>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 44);
+ assert(s.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
+ std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
+ std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
+ std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
+ std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
+
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+}
+
+void test_iter_iter() {
+ const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+ const P sorted_arr[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+ const PC arrc[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+ const PC sorted_arrc[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+ {
+ std::flat_map m(std::begin(arr), std::end(arr));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::begin(arrc), std::end(arrc));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ #if 0
+ {
+ std::flat_map m(std::begin(arr), std::end(arr), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::begin(arrc), std::end(arrc), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ #endif
+ {
+ std::flat_map<int, short> mo;
+ std::flat_map m(mo.begin(), mo.end());
+ ASSERT_SAME_TYPE(decltype(m), decltype(mo));
+ }
+ {
+ std::flat_map<int, short> mo;
+ std::flat_map m(mo.cbegin(), mo.cend());
+ ASSERT_SAME_TYPE(decltype(m), decltype(mo));
+ }
+}
+
+void test_iter_iter_compare() {
+ const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+ const P sorted_arr[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
+ const PC arrc[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+ const PC sorted_arrc[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
+ using C = std::greater<long long>;
+ {
+ std::flat_map m(std::begin(arr), std::end(arr), C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::begin(arrc), std::end(arrc), C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ #if 0
+ {
+ std::flat_map m(std::begin(arr), std::end(arr), C(), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::begin(arrc), std::end(arrc), C(), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C(), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ {
+ std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C(), test_allocator<short>(0, 44));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 44);
+ assert(m.values().get_allocator().get_id() == 44);
+ }
+ #endif
+ {
+ std::flat_map<int, short> mo;
+ std::flat_map m(mo.begin(), mo.end(), C());
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);
+ }
+ {
+ std::flat_map<int, short> mo;
+ std::flat_map m(mo.cbegin(), mo.cend(), C());
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);
+ }
+}
+
+void test_initializer_list() {
+ const P sorted_arr[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+ {
+ std::flat_map m{ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, { std::pair{1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} });
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ #if 0
+ {
+ std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, test_allocator<long>(0, 42));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 42);
+ assert(m.values().get_allocator().get_id() == 42);
+ }
+ {
+ std::flat_map m(std::sorted_unique, { std::pair{1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} }, test_allocator<long>(0, 42));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 42);
+ assert(m.values().get_allocator().get_id() == 42);
+ }
+ #endif
+}
+
+void test_initializer_list_compare() {
+ const P sorted_arr[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
+ using C = std::greater<long long>;
+ {
+ std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ {
+ std::flat_map m(std::sorted_unique, { std::pair{INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} }, C());
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
+ assert(std::ranges::equal(m, sorted_arr));
+ }
+ #if 0
+ {
+ std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C(), test_allocator<long>(0, 42));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 42);
+ assert(m.values().get_allocator().get_id() == 42);
+ }
+ {
+ std::flat_map m(std::sorted_unique, { std::pair{INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} }, C(), test_allocator<long>(0, 42));
+
+ ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
+ assert(std::ranges::equal(m, sorted_arr));
+ assert(m.keys().get_allocator().get_id() == 42);
+ assert(m.values().get_allocator().get_id() == 42);
+ }
+ #endif
+}
+
+void test_from_range() {
+ std::list<std::pair<int, short>> r = { {1,1}, {2,2}, {1,1}, {INT_MAX,4}, {3,5} };
+ const std::pair<int, short> expected[] = { {1,1}, {2,2}, {3,5}, {INT_MAX,4} };
+ {
+ std::flat_map s(std::from_range, r);
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);
+ assert(std::ranges::equal(s, expected));
+ }
+ {
+ std::flat_map s(std::from_range, r, test_allocator<long>(0, 42));
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<short, test_allocator<short>>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 42);
+ }
+}
+
+void test_from_range_compare() {
+ std::list<std::pair<int, short>> r = { {1,1}, {2,2}, {1,1}, {INT_MAX,4}, {3,5} };
+ const std::pair<int, short> expected[] = { {INT_MAX,4}, {3,5}, {2,2}, {1,1} };
+ {
+ std::flat_map s(std::from_range, r, std::greater<int>());
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);
+ assert(std::ranges::equal(s, expected));
+ }
+ {
+ std::flat_map s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::vector<int, test_allocator<int>>, std::vector<short, test_allocator<short>>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().get_id() == 42);
+ assert(s.values().get_allocator().get_id() == 42);
+ }
+}
+
+int main(int, char **)
+{
+ // Each test function also tests the sorted_unique-prefixed and allocator-suffixed overloads.
+ test_copy();
+ test_containers();
+ test_containers_compare();
+ test_iter_iter();
+ test_iter_iter_compare();
+ test_initializer_list();
+ test_initializer_list_compare();
+ test_from_range();
+ test_from_range_compare();
+
+ AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
+
+ {
+ std::flat_map s = { std::make_pair(1, 'a') }; // flat_map(initializer_list<pair<int, char>>)
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, char>);
+ assert(s.size() == 1);
+ }
+ {
+ using M = std::flat_map<int, short>;
+ M m;
+ std::flat_map s = { std::make_pair(m, m) }; // flat_map(initializer_list<pair<M, M>>)
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<M, M>);
+ assert(s.size() == 1);
+ assert(s[m] == m);
+ }
+
+ {
+ std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
+ std::flat_map s = { source, source + 3 }; // flat_map(InputIterator, InputIterator)
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
+ assert(s.size() == 3);
+ }
+ {
+ std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
+ std::flat_map s{ source, source + 3 }; // flat_map(InputIterator, InputIterator)
+ ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
+ assert(s.size() == 3);
+ }
+ {
+ std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
+ std::flat_map s{ std::sorted_unique, source, source + 3 }; // flat_map(sorted_unique_t, InputIterator, InputIterator)
+ static_assert(std::is_same_v<decltype(s), std::flat_map<int, int>>);
+ assert(s.size() == 3);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
new file mode 100644
index 00000000000000..1213279a8e173a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// Test CTAD on cases where deduction should fail.
+
+#include <flat_map>
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+struct NotAnAllocator {
+ friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
+};
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+void test() {
+ {
+ // cannot deduce Key and T from just (KeyContainer), even if it's a container of pairs
+ std::vector<std::pair<int, int>> v;
+ std::flat_map s(v);
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce Key and T from just (KeyContainer, Allocator)
+ std::vector<int> v;
+ std::flat_map s(v, std::allocator<std::pair<const int, int>>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce Key and T from nothing
+ std::flat_map m;
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce Key and T from just (Compare)
+ std::flat_map m(std::less<int>{});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce Key and T from just (Compare, Allocator)
+ std::flat_map m(std::less<int>{}, std::allocator<PC>{});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce Key and T from just (Allocator)
+ std::flat_map m(std::allocator<PC>{});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot convert from some arbitrary unrelated type
+ NotAnAllocator a;
+ std::flat_map m(a);
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce that the inner braced things should be std::pair and not something else
+ std::flat_map m{ {1,1L}, {2,2L}, {3,3L} };
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce that the inner braced things should be std::pair and not something else
+ std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce that the inner braced things should be std::pair and not something else
+ std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>(), std::allocator<PC>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // cannot deduce that the inner braced things should be std::pair and not something else
+ std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::allocator<PC>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+ std::flat_map m(P{1,1L});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+ {
+ // since we have parens, not braces, this deliberately does not find the initializer_list constructor
+ std::flat_map m(PC{1,1L});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ }
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
new file mode 100644
index 00000000000000..4d39c094f13764
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map();
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+
+struct DefaultCtableComp {
+ explicit DefaultCtableComp() { default_constructed_ = true; }
+ bool operator()(int, int) const { return false; }
+ bool default_constructed_ = false;
+};
+
+int main(int, char**)
+{
+ {
+ std::flat_map<int, char*> m;
+ assert(m.empty());
+ }
+ {
+ std::flat_map<int, char*> m = {};
+ assert(m.empty());
+ }
+ {
+ std::flat_map<int, char*, DefaultCtableComp, std::deque<int, min_allocator<int>>> m;
+ assert(m.empty());
+ assert(m.begin() == m.end());
+ assert(m.key_comp().default_constructed_);
+ }
+ {
+ using A1 = explicit_allocator<int>;
+ using A2 = explicit_allocator<char*>;
+ {
+ std::flat_map<int, char*, DefaultCtableComp, std::vector<int, A1>, std::vector<char*, A2>> m;
+ assert(m.empty());
+ assert(m.key_comp().default_constructed_);
+ }
+ {
+ A1 a1;
+ std::flat_map<int, int, DefaultCtableComp, std::vector<int, A1>, std::vector<int, A1>> m(a1);
+ assert(m.empty());
+ assert(m.key_comp().default_constructed_);
+ }
+ }
+ {
+ // If an allocator is given, it must be usable by both containers.
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, std::vector<int, A>>;
+ static_assert(std::is_constructible_v<M>);
+ static_assert(!std::is_constructible_v<M, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, A>);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
new file mode 100644
index 00000000000000..2b920cd28c8783
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map()
+// noexcept(
+// is_nothrow_default_constructible_v<key_container_type> &&
+// is_nothrow_default_constructible_v<mapped_container_type> &&
+// is_nothrow_default_constructible_v<key_compare>);
+
+// This tests a conforming extension
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <vector>
+
+#include "test_macros.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+
+struct ThrowingCtorComp {
+ ThrowingCtorComp() noexcept(false) {}
+ bool operator()(const auto&, const auto&) const { return false; }
+};
+
+int main(int, char**)
+{
+#if defined(_LIBCPP_VERSION)
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly>;
+ static_assert(std::is_nothrow_default_constructible_v<C>);
+ }
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly, std::less<MoveOnly>, std::vector<MoveOnly, test_allocator<MoveOnly>>>;
+ static_assert(std::is_nothrow_default_constructible_v<C>);
+ }
+#endif // _LIBCPP_VERSION
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly, std::less<MoveOnly>, std::vector<MoveOnly, other_allocator<MoveOnly>>>;
+ static_assert(!std::is_nothrow_default_constructible_v<C>);
+ C c;
+ }
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly, ThrowingCtorComp>;
+ static_assert(!std::is_nothrow_default_constructible_v<C>);
+ C c;
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
new file mode 100644
index 00000000000000..43f9dcedfd34af
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// ~flat_map();
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <vector>
+
+#include "test_macros.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+
+struct ThrowingDtorComp {
+ bool operator()(const auto&, const auto&) const;
+ ~ThrowingDtorComp() noexcept(false);
+};
+
+int main(int, char**)
+{
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly>;
+ static_assert(std::is_nothrow_destructible_v<C>);
+ }
+ {
+ using V = std::vector<MoveOnly, test_allocator<MoveOnly>>;
+ using C = std::flat_map<MoveOnly, MoveOnly, std::less<MoveOnly>, V, V>;
+ static_assert(std::is_nothrow_destructible_v<C>);
+ }
+ {
+ using V = std::deque<MoveOnly, other_allocator<MoveOnly>>;
+ using C = std::flat_map<MoveOnly, MoveOnly, std::greater<MoveOnly>, V, V>;
+ static_assert(std::is_nothrow_destructible_v<C>);
+ }
+#if defined(_LIBCPP_VERSION)
+ {
+ using C = std::flat_map<MoveOnly, MoveOnly, ThrowingDtorComp>;
+ static_assert(!std::is_nothrow_destructible_v<C>);
+ }
+#endif // _LIBCPP_VERSION
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
new file mode 100644
index 00000000000000..8e62164be72d7d
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare());
+// template<class Alloc> flat_map(initializer_list<value_type> il, const Alloc& a);
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+struct DefaultCtableComp {
+ explicit DefaultCtableComp() { default_constructed_ = true; }
+ bool operator()(int, int) const { return false; }
+ bool default_constructed_ = false;
+};
+
+int main(int, char**)
+{
+ std::pair<int, short> expected[] = {{1,1}, {2,2}, {3,3}, {5,2}};
+ {
+ using M = std::flat_map<int, short>;
+ M m = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
+ assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ }
+ {
+ using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ M m = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ }
+ {
+ using M = std::flat_map<int, short>;
+ std::initializer_list<M::value_type> il = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
+ M m = il;
+ assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>>);
+ static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
+ }
+ {
+ using A = explicit_allocator<int>;
+ {
+ using M = std::flat_map<int, int, DefaultCtableComp, std::vector<int, A>, std::deque<int, A>>;
+ M m = {{1,1}, {2,2}, {3,3}};
+ assert(m.size() == 1);
+ assert(m.begin()->first == m.begin()->second);
+ LIBCPP_ASSERT(*m.begin() == std::make_pair(1, 1));
+ assert(m.key_comp().default_constructed_);
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
+ A a;
+ M m({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, a);
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ }
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::initializer_list<M::value_type> il = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ vm.emplace_back(il);
+ assert((vm[0] == M{{1,1}, {3,3}, {4,4}, {5,5}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
new file mode 100644
index 00000000000000..10f42816bcdbc3
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare());
+// template<class Alloc> flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+#include "../../../test_compare.h"
+
+int main(int, char**)
+{
+ std::pair<int, short> expected[] = {{1,1}, {2,2}, {3,3}, {5,2}};
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C>;
+ auto m = M({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, C(10));
+ assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ assert(m.key_comp() == C(10));
+ }
+ {
+ // Sorting uses the comparator that was passed in
+ using M = std::flat_map<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
+ auto m = M({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, std::greater<int>());
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ assert(m.key_comp()(2, 1) == true);
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C>;
+ std::initializer_list<M::value_type> il = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
+ auto m = M(il, C(10));
+ assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ assert(m.key_comp() == C(10));
+ static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C>);
+ static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C, std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C, std::allocator<int>>);
+ }
+ {
+ using A = explicit_allocator<int>;
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
+ A a;
+ M m({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, {}, a);
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::initializer_list<M::value_type> il = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ vm.emplace_back(il, C(5));
+ assert((vm[0] == M{{1,1}, {3,3}, {4,4}, {5,5}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ assert(vm[0].key_comp() == C(5));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
new file mode 100644
index 00000000000000..389d3906b5f97e
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare());
+// template<class InputIterator, class Allocator>
+// flat_map(InputIterator first, InputIterator last, const Allocator& a);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ using P = std::pair<int, short>;
+ P ar[] = {{1,1}, {1,2}, {1,3}, {2,4}, {2,5}, {3,6}, {2,7}, {3,8}, {3,9}};
+ P expected[] = {{1,1}, {2,4}, {3,6}};
+ {
+ using M = std::flat_map<int, short>;
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ }
+ {
+ using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<short>>;
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ assert((m.keys() == std::deque<int, min_allocator<int>>{3,2,1}));
+ LIBCPP_ASSERT((m.values() == std::deque<short>{6,4,1}));
+ }
+ {
+ // Test when the operands are of array type (also contiguous iterator type)
+ using M = std::flat_map<int, short, std::greater<int>, std::vector<int, min_allocator<int>>>;
+ auto m = M(ar, ar);
+ assert(m.empty());
+ }
+ {
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(ar, ar + 9, A1(5));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ M m = { ar, ar + 9, A1(5) }; // implicit ctor
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(ar, ar);
+ assert(vm[0].empty());
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
new file mode 100644
index 00000000000000..e2e264edd8e394
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare());
+// template<class InputIterator, class Allocator>
+// flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../../../test_compare.h"
+
+int main(int, char**)
+{
+ using P = std::pair<int, short>;
+ P ar[] = {{1,1}, {1,2}, {1,3}, {2,4}, {2,5}, {3,6}, {2,7}, {3,8}, {3,9}};
+ P expected[] = {{1,1}, {2,4}, {3,6}};
+ {
+ using M = std::flat_map<int, short, std::function<bool(int,int)>>;
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::less<int>());
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp()(1, 2) == true);
+ }
+ {
+ using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::greater<int>());
+ assert(std::ranges::equal(m.keys(), expected | std::views::reverse | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected | std::views::reverse));
+ }
+ {
+ // Test when the operands are of array type (also contiguous iterator type)
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C, std::vector<int, min_allocator<int>>>;
+ auto m = M(ar, ar, C(5));
+ assert(m.empty());
+ assert(m.key_comp() == C(5));
+ }
+ {
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(ar, ar + 9, C(3), A1(5));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp() == C(3));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
+ M m = { ar, ar + 9, {}, A2(5) }; // implicit ctor
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C, std::pmr::vector<int>, std::pmr::deque<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), C(3));
+ assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
+ assert(vm[0].key_comp() == C(3));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(ar, ar, C(4));
+ assert(vm[0].empty());
+ assert(vm[0].key_comp() == C(4));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
new file mode 100644
index 00000000000000..6eb19ce0e2d956
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class InputIterator>
+// flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare())
+//
+// libc++ uses stable_sort to ensure that flat_map's behavior matches map's,
+// in terms of which duplicate items are kept.
+// This tests a conforming extension.
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <flat_map>
+#include <random>
+#include <map>
+
+#include "test_macros.h"
+
+struct Mod256 {
+ bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
+};
+
+int main(int, char**)
+{
+ std::mt19937 randomness;
+ std::pair<uint16_t, uint16_t> pairs[200];
+ for (auto& pair : pairs) {
+ pair = { uint16_t(randomness()), uint16_t(randomness()) };
+ }
+
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200);
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(pairs, pairs + 200);
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200, std::allocator<int>());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(pairs, pairs + 200, std::allocator<int>());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200, Mod256());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(pairs, pairs + 200, Mod256());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ {
+ std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200, Mod256(), std::allocator<int>());
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(pairs, pairs + 200, Mod256(), std::allocator<int>());
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
new file mode 100644
index 00000000000000..20f5c4268921ec
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(flat_map&&);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = test_less<int>;
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ M mo = M({{1,1},{2,2},{3,1}}, C(5), A(7));
+ M m = std::move(mo);
+ assert((m == M{{1,1},{2,2},{3,1}}));
+ assert(m.key_comp() == C(5));
+ assert(m.keys().get_allocator() == A(7));
+ assert(m.values().get_allocator() == A(7));
+
+ assert(mo.empty());
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys().get_allocator() == A(test_alloc_base::moved_value));
+ assert(mo.values().get_allocator() == A(test_alloc_base::moved_value));
+ }
+ {
+ using C = test_less<int>;
+ using A = min_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ M mo = M({{1,1},{2,2},{3,1}}, C(5), A());
+ M m = std::move(mo);
+ assert((m == M{{1,1},{2,2},{3,1}}));
+ assert(m.key_comp() == C(5));
+ assert(m.keys().get_allocator() == A());
+ assert(m.values().get_allocator() == A());
+
+ assert(mo.empty());
+ assert(mo.key_comp() == C(5));
+ assert(m.keys().get_allocator() == A());
+ assert(m.values().get_allocator() == A());
+ }
+ {
+ // A moved-from flat_map maintains its class invariant in the presence of moved-from comparators.
+ using M = std::flat_map<int, int, std::function<bool(int,int)>>;
+ M mo = M({{1,1},{2,2},{3,1}}, std::less<int>());
+ M m = std::move(mo);
+ assert(m.size() == 3);
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
+ assert(m.key_comp()(1,2) == true);
+
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ LIBCPP_ASSERT(m.key_comp()(1,2) == true);
+ LIBCPP_ASSERT(mo.empty());
+ mo.insert({{1,1},{2,2},{3,1}}); // insert has no preconditions
+ assert(m == mo);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
new file mode 100644
index 00000000000000..745680c063ee06
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(flat_map&&, const allocator_type&);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <ranges>
+#include <vector>
+
+#include "test_macros.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+
+int main(int, char**)
+{
+ {
+ std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,1}};
+ using C = test_less<int>;
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ auto mo = M(expected, expected + 3, C(5), A(7));
+ auto m = M(std::move(mo), A(3));
+
+ assert(m.key_comp() == C(5));
+ assert(m.size() == 3);
+ auto [keys, values] = std::move(m).extract();
+ assert(keys.get_allocator() == A(3));
+ assert(values.get_allocator() == A(3));
+ assert(std::ranges::equal(keys, expected | std::views::elements<0>));
+ assert(std::ranges::equal(values, expected | std::views::elements<1>));
+
+ // The original flat_map is moved-from.
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ #if 0
+ assert(mo.empty());
+ #endif
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys().get_allocator() == A(7));
+ assert(mo.values().get_allocator() == A(7));
+ }
+ {
+ std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,1}};
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{1,1}, {3,1}, {1,1}, {2,2}}, C(5), &mr1);
+ M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor
+
+ assert(m.key_comp() == C(5));
+ assert(m.size() == 3);
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+ assert(std::equal(m.begin(), m.end(), expected, expected + 3));
+
+ // The original flat_map is moved-from.
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ assert(mo.values().get_allocator().resource() == &mr1);
+ }
+ {
+ using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
+ std::pmr::vector<M> vs;
+ M m = {{1,1}, {3,1}, {1,1}, {2,2}};
+ vs.push_back(std::move(m));
+ assert((vs[0].keys() == std::pmr::deque<int>{1,2,3}));
+ assert((vs[0].values() == std::pmr::vector<int>{1,2,1}));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
new file mode 100644
index 00000000000000..bf0b0e71a3a827
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(flat_map&&);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+#include "MoveOnly.h"
+#include "../../../test_compare.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<char>;
+ using M = std::flat_map<int, char, C, std::vector<int, A1>, std::vector<char, A2>>;
+ M mo = M({{1,1},{2,3},{3,2}}, C(5), A1(7));
+ M m = M({}, C(3), A1(7));
+ m = std::move(mo);
+ assert((m == M{{1,1},{2,3},{3,2}}));
+ assert(m.key_comp() == C(5));
+ auto [ks, vs] = std::move(m).extract();
+ assert(ks.get_allocator() == A1(7));
+ assert(vs.get_allocator() == A2(7));
+ assert(mo.empty());
+ }
+ {
+ using C = test_less<int>;
+ using A1 = other_allocator<int>;
+ using A2 = other_allocator<char>;
+ using M = std::flat_map<int, char, C, std::deque<int, A1>, std::deque<char, A2>>;
+ M mo = M({{4,5},{5,4}}, C(5), A1(7));
+ M m = M({{1,1},{2,2},{3,3},{4,4}}, C(3), A1(7));
+ m = std::move(mo);
+ assert((m == M{{4,5},{5,4}}));
+ assert(m.key_comp() == C(5));
+ auto [ks, vs] = std::move(m).extract();
+ assert(ks.get_allocator() == A1(7));
+ assert(vs.get_allocator() == A2(7));
+ assert(mo.empty());
+ }
+ {
+ using A = min_allocator<int>;
+ using M = std::flat_map<int, int, std::greater<int>, std::vector<int, A>, std::vector<int, A>>;
+ M mo = M({{5,1},{4,2},{3,3}}, A());
+ M m = M({{4,4},{3,3},{2,2},{1,1}}, A());
+ m = std::move(mo);
+ assert((m == M{{5,1},{4,2},{3,3}}));
+ auto [ks, vs] = std::move(m).extract();
+ assert(ks.get_allocator() == A());
+ assert(vs.get_allocator() == A());
+ assert(mo.empty());
+ }
+ {
+ // A moved-from flat_map maintains its class invariant in the presence of moved-from elements.
+ using M = std::flat_map<std::pmr::string, int, std::less<>, std::pmr::vector<std::pmr::string>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{"short", 1}, {"very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move", 2}}, &mr1);
+ M m = M({{"don't care", 3}}, &mr2);
+ m = std::move(mo);
+ assert(m.size() == 2);
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
+ assert(m.begin()->first.get_allocator().resource() == &mr2);
+
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ mo.insert({"foo",1});
+ assert(mo.begin()->first.get_allocator().resource() == &mr1);
+ }
+ {
+ // A moved-from flat_map maintains its class invariant in the presence of moved-from comparators.
+ using C = std::function<bool(int,int)>;
+ using M = std::flat_map<int, int, C>;
+ M mo = M({{1,3},{2,2},{3,1}}, std::less<int>());
+ M m = M({{1,1},{2,2}}, std::greater<int>());
+ m = std::move(mo);
+ assert(m.size() == 3);
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
+ assert(m.key_comp()(1,2) == true);
+
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ LIBCPP_ASSERT(m.key_comp()(1,2) == true);
+ LIBCPP_ASSERT(mo.empty());
+ mo.insert({{1,3},{2,2},{3,1}}); // insert has no preconditions
+ LIBCPP_ASSERT(m == mo);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
new file mode 100644
index 00000000000000..95fcb1e5e0c273
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(flat_map&&);
+// Preserves the class invariant for the moved-from flat_map.
+
+#include <algorithm>
+#include <cassert>
+#include <compare>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+
+struct MoveNegates {
+ int value_ = 0;
+ MoveNegates() = default;
+ MoveNegates(int v) : value_(v) {}
+ MoveNegates(MoveNegates&& rhs) : value_(rhs.value_) { rhs.value_ = -rhs.value_; }
+ MoveNegates& operator=(MoveNegates&& rhs) { value_ = rhs.value_; rhs.value_ = -rhs.value_; return *this; }
+ ~MoveNegates() = default;
+ auto operator<=>(const MoveNegates&) const = default;
+};
+
+struct MoveClears {
+ int value_ = 0;
+ MoveClears() = default;
+ MoveClears(int v) : value_(v) {}
+ MoveClears(MoveClears&& rhs) : value_(rhs.value_) { rhs.value_ = 0; }
+ MoveClears& operator=(MoveClears&& rhs) { value_ = rhs.value_; rhs.value_ = 0; return *this; }
+ ~MoveClears() = default;
+ auto operator<=>(const MoveClears&) const = default;
+};
+
+int main(int, char**)
+{
+ auto value_eq = [](auto&& p, auto&& q) { return p.first == q.first; };
+ {
+ const std::pair<int, int> expected[] = { {1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8} };
+ using M = std::flat_map<MoveNegates, int, std::less<MoveNegates>, std::vector<MoveNegates>>;
+ M m = M(expected, expected + 8);
+ M m2 = M(expected, expected + 3);
+
+ m2 = std::move(m);
+
+ assert(std::equal(m2.begin(), m2.end(), expected, expected+8));
+ LIBCPP_ASSERT(m.empty());
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
+ assert(std::adjacent_find(m.begin(), m.end(), value_eq) == m.end()); // still contains no duplicates
+ m.insert({1,1});
+ m.insert({2,2});
+ assert(m.contains(1));
+ assert(m.find(2) != m.end());
+ }
+ {
+ const std::pair<int, int> expected[] = { {1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8} };
+ using M = std::flat_map<MoveClears, int, std::less<MoveClears>, std::vector<MoveClears>>;
+ M m = M(expected, expected + 8);
+ M m2 = M(expected, expected + 3);
+
+ m2 = std::move(m);
+
+ assert(std::equal(m2.begin(), m2.end(), expected, expected+8));
+ LIBCPP_ASSERT(m.empty());
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
+ assert(std::adjacent_find(m.begin(), m.end(), value_eq) == m.end()); // still contains no duplicates
+ m.insert({1,1});
+ m.insert({2,2});
+ assert(m.contains(1));
+ assert(m.find(2) != m.end());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
new file mode 100644
index 00000000000000..5c9514089cb55b
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map& operator=(flat_map&& c)
+// noexcept(
+// is_nothrow_move_assignable<key_container_type>::value &&
+// is_nothrow_move_assignable<mapped_container_type>::value &&
+// is_nothrow_copy_assignable<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <type_traits>
+#include <vector>
+
+#include "MoveOnly.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+struct MoveSensitiveComp {
+ MoveSensitiveComp() noexcept(false) = default;
+ MoveSensitiveComp(const MoveSensitiveComp&) noexcept(false) = default;
+ MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; }
+ MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept = default;
+ MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; return *this; }
+ bool operator()(const auto&, const auto&) const { return false; }
+ bool is_moved_from_ = false;
+};
+
+int main(int, char**)
+{
+ {
+ using C = std::flat_map<int, int>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ using C = std::flat_map<MoveOnly, int, std::less<MoveOnly>, std::vector<MoveOnly, test_allocator<MoveOnly>>, std::vector<int, test_allocator<int>>>;
+ static_assert(!std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ using C = std::flat_map<int, MoveOnly, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<MoveOnly, test_allocator<MoveOnly>>>;
+ static_assert(!std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ using C = std::flat_map<MoveOnly, int, std::less<MoveOnly>, std::vector<MoveOnly, other_allocator<MoveOnly>>, std::vector<int, other_allocator<int>>>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ using C = std::flat_map<int, MoveOnly, std::less<int>, std::vector<int, other_allocator<int>>, std::vector<MoveOnly, other_allocator<MoveOnly>>>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ // Test with a comparator that throws on copy-assignment.
+ using C = std::flat_map<int, int, std::function<bool(int,int)>>;
+ LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ // Test with a container that throws on move-assignment.
+ using C = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::vector<int>>;
+ static_assert(!std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ // Test with a container that throws on move-assignment.
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int>, std::pmr::vector<int>>;
+ static_assert(!std::is_nothrow_move_assignable_v<C>);
+ }
+ {
+ // Moving the flat_map copies the comparator (to support std::function comparators)
+ using C = std::flat_map<int, int, MoveSensitiveComp>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
+ C c;
+ assert(!c.key_comp().is_moved_from_);
+ C d;
+ d = std::move(c);
+ LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
+ assert(!d.key_comp().is_moved_from_);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
new file mode 100644
index 00000000000000..2e7d5c95a08d14
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+
+// <flat_map>
+
+// flat_map(flat_map&& s);
+// If any member function in [flat.map.defn] exits via an exception, the invariant is restored.
+
+#include <algorithm>
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+//#include "MinSequenceContainer.h"
+
+static int countdown = 0;
+
+struct EvilContainer : std::vector<int> {
+ EvilContainer() = default;
+ EvilContainer(EvilContainer&& rhs) {
+ // Throw on move-construction.
+ if (--countdown == 0) {
+ rhs.insert(rhs.end(), 0);
+ rhs.insert(rhs.end(), 0);
+ throw 42;
+ }
+ }
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, int, std::less<int>, EvilContainer, std::vector<int>>;
+ M mo = {{1,1}, {2,2}, {3,3}};
+ countdown = 1;
+ try {
+ M m = std::move(mo);
+ assert(false); // not reached
+ } catch (int x) {
+ assert(x == 42);
+ }
+ // The source flat_map maintains its class invariant.
+ assert(mo.keys().size() == mo.values().size());
+ assert(std::is_sorted(mo.begin(), mo.end()));
+ assert(std::adjacent_find(mo.keys().begin(), mo.keys().end()) == mo.keys().end());
+ LIBCPP_ASSERT(mo.empty());
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int>, EvilContainer>;
+ M mo = {{1,1}, {2,2}, {3,3}};
+ countdown = 1;
+ try {
+ M m = std::move(mo);
+ assert(false); // not reached
+ } catch (int x) {
+ assert(x == 42);
+ }
+ // The source flat_map maintains its class invariant.
+ assert(mo.keys().size() == mo.values().size());
+ assert(std::is_sorted(mo.begin(), mo.end()));
+ assert(std::adjacent_find(mo.keys().begin(), mo.keys().end()) == mo.keys().end());
+ LIBCPP_ASSERT(mo.empty());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
new file mode 100644
index 00000000000000..ee7798b8738f12
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(flat_map&&)
+// noexcept(is_nothrow_move_constructible<key_container_type>::value &&
+// is_nothrow_move_constructible<mapped_container_type>::value &&
+// is_nothrow_copy_constructible<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+
+template <class T>
+struct ThrowingMoveAllocator {
+ using value_type = T;
+ explicit ThrowingMoveAllocator() = default;
+ ThrowingMoveAllocator(const ThrowingMoveAllocator&) = default;
+ ThrowingMoveAllocator(ThrowingMoveAllocator&&) noexcept(false) {}
+ T *allocate(std::ptrdiff_t n) { return std::allocator<T>().allocate(n); }
+ void deallocate(T *p, std::ptrdiff_t n) { return std::allocator<T>().deallocate(p, n); }
+ friend bool operator==(ThrowingMoveAllocator, ThrowingMoveAllocator) = default;
+};
+
+struct ThrowingCopyComp {
+ ThrowingCopyComp() = default;
+ ThrowingCopyComp(const ThrowingCopyComp&) noexcept(false) {}
+ ThrowingCopyComp(ThrowingCopyComp&&) noexcept {}
+ bool operator()(const auto&, const auto&) const { return false; }
+};
+
+struct MoveSensitiveComp {
+ MoveSensitiveComp() noexcept(false) = default;
+ MoveSensitiveComp(const MoveSensitiveComp&) noexcept = default;
+ MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; }
+ MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept(false) = default;
+ MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; return *this; }
+ bool operator()(const auto&, const auto&) const { return false; }
+ bool is_moved_from_ = false;
+};
+
+int main(int, char**)
+{
+ {
+ using C = std::flat_map<int, int>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);
+ C c;
+ C d = std::move(c);
+ }
+ {
+ using C = std::flat_map<int, int, std::less<int>, std::deque<int, test_allocator<int>>>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);
+ C c;
+ C d = std::move(c);
+ }
+#if _LIBCPP_VERSION
+ {
+ // Container fails to be nothrow-move-constructible; this relies on libc++'s support for non-nothrow-copyable allocators
+ using C = std::flat_map<int, int, std::less<int>, std::deque<int, ThrowingMoveAllocator<int>>, std::vector<int>>;
+ static_assert(!std::is_nothrow_move_constructible_v<std::deque<int, ThrowingMoveAllocator<int>>>);
+ static_assert(!std::is_nothrow_move_constructible_v<C>);
+ C c;
+ C d = std::move(c);
+ }
+ {
+ // Container fails to be nothrow-move-constructible; this relies on libc++'s support for non-nothrow-copyable allocators
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int>, std::deque<int, ThrowingMoveAllocator<int>>>;
+ static_assert(!std::is_nothrow_move_constructible_v<std::deque<int, ThrowingMoveAllocator<int>>>);
+ static_assert(!std::is_nothrow_move_constructible_v<C>);
+ C c;
+ C d = std::move(c);
+ }
+#endif // _LIBCPP_VERSION
+ {
+ // Comparator fails to be nothrow-copy-constructible
+ using C = std::flat_map<int, int, ThrowingCopyComp>;
+ static_assert(!std::is_nothrow_move_constructible_v<C>);
+ C c;
+ C d = std::move(c);
+ }
+ {
+ // Moving the flat_map copies the comparator (to support std::function comparators)
+ using C = std::flat_map<int, int, MoveSensitiveComp>;
+ LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);
+ C c;
+ assert(!c.key_comp().is_moved_from_);
+ C d = std::move(c);
+ LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
+ assert(!d.key_comp().is_moved_from_);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
new file mode 100644
index 00000000000000..106885cdd36b8b
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
+// const key_compare& comp = key_compare());
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "MoveOnly.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ std::vector<int> ks = {1,2,4,10};
+ std::vector<char> vs = {4,3,2,1};
+ auto m = M(std::sorted_unique, ks, vs);
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ m = M(std::sorted_unique, std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ }
+ {
+ using Ks = std::deque<int, min_allocator<int>>;
+ using Vs = std::deque<char, min_allocator<char>>;
+ using M = std::flat_map<int, char, std::greater<int>, Ks, Vs>;
+ Ks ks = {10,4,2,1};
+ Vs vs = {1,2,3,4};
+ auto m = M(std::sorted_unique, ks, vs);
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ m = M(std::sorted_unique, std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,2,4,10}, A(4));
+ auto vs = std::deque<int, A>({4,3,2,1}, A(5));
+ auto m = M(std::sorted_unique, std::move(ks), std::move(vs));
+ assert(ks.empty()); // it was moved-from
+ assert(vs.empty()); // it was moved-from
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert(m.keys().get_allocator() == A(4));
+ assert(m.values().get_allocator() == A(5));
+ }
+ {
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
+ auto ks = std::vector<int, A>({1,2,4,10}, A(4));
+ auto vs = std::deque<int, A>({4,3,2,1}, A(5));
+ auto m = M(std::sorted_unique, ks, vs, A(6)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert(m.keys().get_allocator() == A(6));
+ assert(m.values().get_allocator() == A(6));
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,2,4,10};
+ std::pmr::vector<int> vs = {4,3,2,1};
+ vm.emplace_back(std::sorted_unique, ks, vs);
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1,2,4,10};
+ std::pmr::vector<int> vs = {4,3,2,1};
+ vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
+ LIBCPP_ASSERT(ks.size() == 4); // ks' size is unchanged, since it uses a different allocator
+ LIBCPP_ASSERT(vs.size() == 4); // vs' size is unchanged, since it uses a different allocator
+ assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ #if 0
+ {
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks({1,2,4,10}, &mr);
+ std::pmr::vector<int> vs({4,3,2,1}, &mr);
+ vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
+ assert(ks.empty()); // ks is moved-from (after LWG 3802)
+ assert(vs.empty()); // vs is moved-from (after LWG 3802)
+ assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
+ std::pmr::vector<M> vm;
+ std::pmr::vector<MoveOnly> ks;
+ std::pmr::vector<MoveOnly> vs;
+ vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs)); // this was a hard error before LWG 3802
+ assert(vm.size() == 1);
+ assert(vm[0].empty());
+ }
+ #endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
new file mode 100644
index 00000000000000..b5852d40ea9104
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare());
+// template<class InputIterator, class Allocator>
+// flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../../../test_compare.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, int, std::function<bool(int,int)>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
+ auto m = M(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), std::less<int>());
+ assert(m == M({{1,1}, {2,2}, {4,4}, {5,5}}, std::less<>()));
+ assert(m.key_comp()(1, 2) == true);
+ }
+ {
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{5,5}, {4,4}, {2,2}, {1,1}};
+ auto m = M(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), std::greater<int>());
+ assert((m == M{{5,5}, {4,4}, {2,2}, {1,1}}));
+ }
+ {
+ // Test when the operands are of array type (also contiguous iterator type)
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
+ std::pair<int, int> ar[1] = {{42,42}};
+ auto m = M(std::sorted_unique, ar, ar, C(5));
+ assert(m.empty());
+ assert(m.key_comp() == C(5));
+ }
+ {
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
+ auto m = M(std::sorted_unique, ar, ar + 4, C(3), A1(5));
+ assert((m == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ assert(m.key_comp() == C(3));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using A1 = test_allocator<short>;
+ using A2 = test_allocator<int>;
+ using M = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
+ M m = { std::sorted_unique, ar, ar + 4, {}, A1(5) }; // implicit ctor
+ assert((m == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ using P = std::pair<int, int>;
+ P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
+ vm.emplace_back(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
+ assert((vm[0] == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ assert(vm[0].key_comp() == C(3));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pair<int, int> ar[1] = {{42,42}};
+ vm.emplace_back(std::sorted_unique, ar, ar, C(4));
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp() == C(4));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
new file mode 100644
index 00000000000000..c11aea1364e3a4
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class Key, class T, class Compare, class KeyContainer, class MappedContainer, class Predicate>
+// typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+// erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <initializer_list>
+#include <vector>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+// Verify that `flat_map` (like `map`) does NOT support std::erase.
+//
+template <class S>
+concept HasStdErase = requires (S& s, typename S::value_type x) {
+ std::erase(s, x);
+};
+static_assert(HasStdErase<std::vector<int>>);
+static_assert(!HasStdErase<std::flat_map<int, int>>);
+
+template <class M>
+M make(std::initializer_list<int> vals)
+{
+ M ret;
+ for (int v : vals)
+ ret[static_cast<typename M::key_type>(v)] = static_cast<typename M::mapped_type>(v + 10);
+ return ret;
+}
+
+template <class M, class Pred>
+void test0(std::initializer_list<int> vals, Pred p, std::initializer_list<int> expected, std::size_t expected_erased_count) {
+ M s = make<M>(vals);
+ ASSERT_SAME_TYPE(typename M::size_type, decltype(std::erase_if(s, p)));
+ assert(expected_erased_count == std::erase_if(s, p));
+ assert(s == make<M>(expected));
+}
+
+template <class S>
+void test()
+{
+ // Test all the plausible signatures for this predicate.
+ auto is1 = [](typename S::const_reference v) { return v.first == 1;};
+ auto is2 = [](typename S::value_type v) { return v.first == 2;};
+ auto is3 = [](const typename S::value_type& v) { return v.first == 3;};
+ auto is4 = [](auto v) { return v.first == 4;};
+ auto True = [](const auto&) { return true; };
+ auto False = [](auto&&) { return false; };
+
+ test0<S>({}, is1, {}, 0);
+
+ test0<S>({1}, is1, {}, 1);
+ test0<S>({1}, is2, {1}, 0);
+
+ test0<S>({1, 2}, is1, {2}, 1);
+ test0<S>({1, 2}, is2, {1}, 1);
+ test0<S>({1, 2}, is3, {1, 2}, 0);
+
+ test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+ test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+ test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+ test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
+
+ test0<S>({1, 2, 3}, True, {}, 3);
+ test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
+}
+
+int main(int, char**)
+{
+ test<std::flat_map<int, char>>();
+ test<std::flat_map<int, char, std::less<int>, std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>>();
+ test<std::flat_map<int, char, std::greater<int>, std::vector<int, test_allocator<int>>>>();
+ test<std::flat_map<int, char, std::less<int>, std::deque<int, min_allocator<int>>>>();
+ test<std::flat_map<int, char, std::greater<int>, std::deque<int, test_allocator<int>>>>();
+ test<std::flat_map<long, int>>();
+ test<std::flat_map<double, int>>();
+ {
+ using M = std::flat_map<bool, bool>;
+ std::flat_map<bool, bool> fs = {{true,false}, {false,true}};
+ std::same_as<size_t> auto n = std::erase_if(fs, [](M::const_reference x) { return x.first; });
+ assert((fs == M{{false,true}}));
+ assert(n == 1);
+ n = std::erase_if(fs, [](const M::value_type& x) { return !x.first; });
+ assert(fs.empty());
+ assert(n == 1);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
new file mode 100644
index 00000000000000..fcda037112f941
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
@@ -0,0 +1,162 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+
+// <flat_map>
+
+// template<class Key, class T, class Compare, class KeyContainer, class MappedContainer, class Predicate>
+// typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+// erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+// If any member function in [flat.set.defn] exits via an exception, the invariant is restored.
+// (This is not a member function, but let's respect the invariant anyway.)
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+
+struct Counter {
+ int c1, c2, throws;
+ void tick() {
+ c1 -= 1;
+ if (c1 == 0) {
+ c1 = c2;
+ throws += 1;
+ throw 42;
+ }
+ }
+};
+Counter g_counter = {0,0,0};
+
+struct ThrowingAssignment {
+ ThrowingAssignment(int i) : i_(i) {}
+ ThrowingAssignment(const ThrowingAssignment&) = default;
+ ThrowingAssignment& operator=(const ThrowingAssignment& rhs) {
+ g_counter.tick();
+ i_ = rhs.i_;
+ g_counter.tick();
+ return *this;
+ }
+ operator int() const { return i_; }
+ int i_;
+};
+
+struct ThrowingComparator {
+ bool operator()(const ThrowingAssignment& a, const ThrowingAssignment& b) const {
+ g_counter.tick();
+ return a.i_ < b.i_;
+ }
+};
+
+struct ErasurePredicate {
+ bool operator()(const auto& x) const {
+ return (3 <= x.first && x.first <= 5);
+ }
+};
+
+int main(int, char**)
+{
+ const std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
+ {
+ using M = std::flat_map<ThrowingAssignment, int, ThrowingComparator>;
+ for (int first_throw = 1; first_throw < 99; ++first_throw) {
+ for (int second_throw = 1; second_throw < 99; ++second_throw) {
+ g_counter = {0,0,0};
+ M m = M({1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8});
+ try {
+ g_counter = {first_throw, second_throw, 0};
+ auto n = std::erase_if(m, ErasurePredicate());
+ assert(n == 3);
+ // If it didn't throw at all, we're done.
+ g_counter = {0,0,0};
+ assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
+ first_throw = 99; // "done"
+ break;
+ } catch (int ex) {
+ assert(ex == 42);
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ if (g_counter.throws == 1) {
+ // We reached the first throw but not the second throw.
+ break;
+ }
+ }
+ }
+ }
+ }
+ {
+ using M = std::flat_map<int, ThrowingAssignment, ThrowingComparator>;
+ for (int first_throw = 1; first_throw < 99; ++first_throw) {
+ for (int second_throw = 1; second_throw < 99; ++second_throw) {
+ g_counter = {0,0,0};
+ M m = M({1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8});
+ try {
+ g_counter = {first_throw, second_throw, 0};
+ auto n = std::erase_if(m, ErasurePredicate());
+ assert(n == 3);
+ // If it didn't throw at all, we're done.
+ g_counter = {0,0,0};
+ assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
+ first_throw = 99; // "done"
+ break;
+ } catch (int ex) {
+ assert(ex == 42);
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ if (g_counter.throws == 1) {
+ // We reached the first throw but not the second throw.
+ break;
+ }
+ }
+ }
+ }
+ }
+ {
+ using M = std::flat_map<ThrowingAssignment, int, ThrowingComparator, std::deque<ThrowingAssignment>, std::deque<int>>;
+ for (int first_throw = 1; first_throw < 99; ++first_throw) {
+ for (int second_throw = 1; second_throw < 99; ++second_throw) {
+ g_counter = {0,0,0};
+ std::deque<ThrowingAssignment> container = {5,6,7,8};
+ container.insert(container.begin(), {1,2,3,4});
+ M m = M(std::move(container), {1,2,3,4,5,6,7,8});
+ try {
+ g_counter = {first_throw, second_throw, 0};
+ auto n = std::erase_if(m, ErasurePredicate());
+ assert(n == 3);
+ // If it didn't throw at all, we're done.
+ g_counter = {0,0,0};
+ assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
+ first_throw = 99; // "done"
+ break;
+ } catch (int ex) {
+ assert(ex == 42);
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ if (g_counter.throws == 1) {
+ // We reached the first throw but not the second throw.
+ break;
+ }
+ }
+ }
+ }
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
new file mode 100644
index 00000000000000..68a40dd5b7f6dc
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// Check that std::flat_map and its iterators can be instantiated with an incomplete
+// type.
+
+#include <flat_map>
+
+#include "test_macros.h"
+
+struct A {
+ using Map = std::flat_map<A, A>;
+ int data;
+ Map m;
+ Map::iterator it;
+ Map::const_iterator cit;
+};
+
+// Implement the operator< required in order to instantiate flat_map<A, X>
+bool operator<(A const& L, A const& R) { return L.data < R.data; }
+
+int main(int, char**) {
+ A a;
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
new file mode 100644
index 00000000000000..513f72f11cc3f6
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<container-compatible-range<value_type> R>
+// void insert_range(R&& rg);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <ranges>
+#include <vector>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int>;
+ using It = forward_iterator<const P*>;
+ M m = {{10,1}, {8,2}, {5,3}, {2,4}, {1,5}};
+ P ar[] = {{3,1}, {1,2}, {4,3}, {1,4}, {5,5}, {9,6}};
+ std::ranges::subrange r = { It(ar), It(ar + 6) };
+ static_assert(std::ranges::common_range<decltype(r)>);
+ m.insert_range(r);
+ assert((m == M{{1,5}, {2,4}, {3,1}, {4,3}, {5,3}, {8,2}, {9,6}, {10,1}}));
+ }
+ {
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>>;
+ using It = cpp20_input_iterator<const P*>;
+ M m = {{8,1}, {5,2}, {3,3}, {2,4}};
+ P ar[] = {{3,1}, {1,2}, {4,3}, {1,4}, {5,5}, {9,6}};
+ std::ranges::subrange r = { It(ar), sentinel_wrapper<It>(It(ar + 6)) };
+ static_assert(!std::ranges::common_range<decltype(r)>);
+ m.insert_range(r);
+ assert((m == M{{1,2}, {2,4}, {3,3}, {4,3}, {5,2}, {8,1}, {9,6}}));
+ }
+ {
+ // The "uniquing" part uses the comparator, not operator==.
+ struct ModTen {
+ bool operator()(int a, int b) const { return (a % 10) < (b % 10); }
+ };
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int, ModTen>;
+ M m = {{21,0}, {43,0}, {15,0}, {37,0}};
+ P ar[] = {{33,1}, {18,1}, {55,1}, {18,1}, {42,1}};
+ m.insert_range(ar);
+ assert((m == M{{21,0}, {42,1}, {43,0}, {15,0}, {37,0}, {18,1}}));
+ }
+ {
+ // The "uniquing" part uses the comparator, not operator==.
+ struct ModTen {
+ bool operator()(int a, int b) const { return (a % 10) < (b % 10); }
+ };
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int, ModTen>;
+ M m = {{21,0}, {43,0}, {15,0}, {37,0}};
+ P ar[] = {{33,1}, {18,1}, {55,1}, {28,1}, {42,1}};
+ m.insert_range(ar);
+ LIBCPP_ASSERT((m == M{{21,0}, {42,1}, {43,0}, {15,0}, {37,0}, {18,1}}));
+ }
+ {
+ // Items are forwarded correctly from the input range (P2767).
+ std::pair<MoveOnly, MoveOnly> a[] = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ std::flat_map<MoveOnly, MoveOnly> m;
+ m.insert_range(a | std::views::as_rvalue);
+ std::pair<MoveOnly, MoveOnly> expected[] = {{1,1}, {3,3}, {4,4}, {5,5}};
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // The element type of the range doesn't need to be std::pair (P2767).
+ std::pair<int, int> pa[] = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ std::deque<std::reference_wrapper<std::pair<int, int>>> a(pa, pa+5);
+ std::flat_map<int, int> m;
+ m.insert_range(a);
+ std::pair<int, int> expected[] = {{1,1}, {3,3}, {4,4}, {5,5}};
+ assert(std::ranges::equal(m, expected));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
new file mode 100644
index 00000000000000..426067105b76df
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<container-compatible-range<value_type> R>
+// void insert_range(R&& rg);
+//
+// libc++ uses stable_sort to ensure that flat_map's behavior matches map's,
+// in terms of which duplicate items are kept.
+// This tests a conforming extension.
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <flat_map>
+#include <random>
+#include <ranges>
+#include <map>
+
+#include "test_macros.h"
+
+struct Mod256 {
+ bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
+};
+
+int main(int, char**)
+{
+ {
+ std::mt19937 randomness;
+ std::pair<uint16_t, uint16_t> pairs[400];
+ for (int i = 0; i < 400; ++i) {
+ uint16_t r = randomness();
+ pairs[i] = {r, r};
+ }
+
+ std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200);
+ std::flat_map<uint16_t, uint16_t, Mod256> fm(std::sorted_unique, m.begin(), m.end());
+ assert(std::ranges::equal(fm, m));
+
+ fm.insert_range(std::views::counted(pairs + 200, 200));
+ m.insert(pairs + 200, pairs + 400);
+ assert(fm.size() == m.size());
+ LIBCPP_ASSERT(std::ranges::equal(fm, m));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
new file mode 100644
index 00000000000000..14fc0fab591684
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
@@ -0,0 +1,121 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> pair<iterator, bool> insert(P&& x);
+// template<class K> iterator insert(const_iterator hint, P&& x);
+
+#include <algorithm>
+#include <compare>
+#include <concepts>
+#include <flat_map>
+#include <functional>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+
+static int expensive_comparisons = 0;
+static int cheap_comparisons = 0;
+
+struct CompareCounter {
+ int i_ = 0;
+ CompareCounter(int i) : i_(i) {}
+ friend auto operator<=>(const CompareCounter& x, const CompareCounter& y) {
+ expensive_comparisons += 1;
+ return x.i_ <=> y.i_;
+ }
+ bool operator==(const CompareCounter&) const = default;
+ friend auto operator<=>(const CompareCounter& x, int y) {
+ cheap_comparisons += 1;
+ return x.i_ <=> y;
+ }
+};
+
+int main(int, char**)
+{
+ const std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}};
+ {
+ // insert(P&&)
+ // Unlike flat_set, here we can't use key_compare to compare value_type versus P,
+ // so we must eagerly convert to value_type.
+ using M = std::flat_map<CompareCounter, int, std::less<>>;
+ M m = {{1,1}, {2,2}, {4,4}, {5,5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3,3)); // conversion happens first
+ assert(expensive_comparisons >= 2);
+ assert(cheap_comparisons == 0);
+ assert(p == std::make_pair(m.begin() + 2, true));
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // insert(const_iterator, P&&)
+ using M = std::flat_map<CompareCounter, int, std::less<>>;
+ M m = {{1,1}, {2,2}, {4,4}, {5,5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3,3));
+ assert(expensive_comparisons >= 2);
+ assert(cheap_comparisons == 0);
+ assert(it == m.begin() + 2);
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // insert(value_type&&)
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1,1}, {2,2}, {4,4}, {5,5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3,3)); // conversion happens last
+ assert(expensive_comparisons >= 2);
+ assert(cheap_comparisons == 0);
+ assert(p == std::make_pair(m.begin() + 2, true));
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // insert(const_iterator, value_type&&)
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1,1}, {2,2}, {4,4}, {5,5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3,3));
+ assert(expensive_comparisons >= 2);
+ assert(cheap_comparisons == 0);
+ assert(it == m.begin() + 2);
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // emplace(Args&&...)
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1,1}, {2,2}, {4,4}, {5,5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.emplace(std::make_pair(3,3)); // conversion happens first
+ assert(expensive_comparisons >= 2);
+ assert(cheap_comparisons == 0);
+ assert(p == std::make_pair(m.begin() + 2, true));
+ assert(std::ranges::equal(m, expected));
+ }
+ {
+ // no ambiguity between insert(pos, P&&) and insert(first, last)
+ using M = std::flat_map<int, int>;
+ struct Evil {
+ operator M::value_type() const;
+ operator M::const_iterator() const;
+ };
+ std::flat_map<int, int> m;
+ ASSERT_SAME_TYPE(decltype(m.insert(Evil())), std::pair<M::iterator, bool>);
+ ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), Evil())), M::iterator);
+ ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), m.end())), void);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
new file mode 100644
index 00000000000000..20e941cb64337a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator begin();
+// const_iterator begin() const;
+// iterator end();
+// const_iterator end() const;
+//
+// const_iterator cbegin() const;
+// const_iterator cend() const;
+
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <string>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
+ M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ ASSERT_SAME_TYPE(decltype(m.begin()), M::iterator);
+ ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.end()), M::iterator);
+ ASSERT_SAME_TYPE(decltype(m.cend()), M::const_iterator);
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(std::distance(m.cbegin(), m.cend()) == 4);
+ M::iterator i; // default-construct
+ i = m.begin(); // move-assignment
+ M::const_iterator k = i; // converting constructor
+ assert(i == k); // comparison
+ for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
+ assert(i->first == j); // operator->
+ assert(i->second == 'a' + j - 1);
+ }
+ assert(i == m.end());
+ for (int j = 4; j >= 1; --j) {
+ --i; // pre-decrement
+ assert((*i).first == j);
+ assert((*i).second == 'a' + j - 1);
+ }
+ assert(i == m.begin());
+ }
+ {
+ using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
+ const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ ASSERT_SAME_TYPE(decltype(m.begin()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.end()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.cend()), M::const_iterator);
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(std::distance(m.cbegin(), m.cend()) == 4);
+ M::const_iterator i; // default-construct
+ i = m.begin(); // move-assignment
+ for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
+ assert(i->first == j);
+ assert(i->second == 'a' + j - 1);
+ }
+ assert(i == m.end());
+ for (int j = 4; j >= 1; --j) {
+ --i; // pre-decrement
+ assert((*i).first == j);
+ assert((*i).second == 'a' + j - 1);
+ }
+ assert(i == m.begin());
+ }
+ {
+ // N3644 testing
+ using C = std::flat_map<int, char>;
+ C::iterator ii1{}, ii2{};
+ C::iterator ii4 = ii1;
+ C::const_iterator cii{};
+ assert(ii1 == ii2);
+ assert(ii1 == ii4);
+ assert(!(ii1 != ii2));
+
+ assert( (ii1 == cii));
+ assert( (cii == ii1));
+ assert(!(ii1 != cii));
+ assert(!(cii != ii1));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
new file mode 100644
index 00000000000000..22ebc599b3f245
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// flat_map iterators should be C++20 random access iterators
+// supporting `operator<=>`, even when the underlying container's
+// iterators are not.
+
+#include <compare>
+#include <concepts>
+#include <flat_map>
+#include <functional>
+
+#include "MinSequenceContainer.h"
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ {
+ using V = MinSequenceContainer<int, random_access_iterator<int*>, random_access_iterator<const int*>>;
+ using M = std::flat_map<int, int, std::less<int>, V, V>;
+ using VI = V::iterator;
+ using VCI = V::const_iterator;
+ using I = M::iterator;
+ using CI = M::const_iterator;
+ using RI = M::reverse_iterator;
+ using CRI = M::const_reverse_iterator;
+ static_assert(!std::three_way_comparable<VI>); // But, despite this...
+ static_assert(!std::three_way_comparable<VCI>);
+ static_assert(std::three_way_comparable<I>); // ...the wrapped iterators support <=>.
+ static_assert(std::three_way_comparable<CI>);
+ static_assert(std::three_way_comparable<RI>);
+ static_assert(std::three_way_comparable<CRI>);
+ static_assert(std::same_as<decltype(I() <=> I()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(I() <=> CI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(CI() <=> CI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
+ }
+ {
+ using V = MinSequenceContainer<int, int*, const int*>;
+ using M = std::flat_map<int, int, std::less<int>, V, V>;
+ using VI = V::iterator;
+ using VCI = V::const_iterator;
+ using I = M::iterator;
+ using CI = M::const_iterator;
+ using RI = M::reverse_iterator;
+ using CRI = M::const_reverse_iterator;
+ static_assert(std::three_way_comparable<VI>); // And when VI does support <=>...
+ static_assert(std::three_way_comparable<VCI>);
+ static_assert(std::three_way_comparable<I>); // ...of course the wrapped iterators still support <=>.
+ static_assert(std::three_way_comparable<CI>);
+ static_assert(std::three_way_comparable<RI>);
+ static_assert(std::three_way_comparable<CRI>);
+ static_assert(std::same_as<decltype(I() <=> I()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(I() <=> CI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(CI() <=> CI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
+ static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
new file mode 100644
index 00000000000000..ddb68b11b20ee8
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
@@ -0,0 +1,142 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator, const_iterator, reverse_iterator, const_reverse_iterator
+
+#include <flat_map>
+#include <deque>
+#include <functional>
+#include <iterator>
+#include <string>
+#include <vector>
+
+#include "test_macros.h"
+
+void test() {
+ {
+ using C = std::flat_map<int, char>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
+ using CRI = C::const_reverse_iterator;
+ static_assert(std::random_access_iterator<I>);
+ static_assert(std::random_access_iterator<CI>);
+ static_assert(std::random_access_iterator<RI>);
+ static_assert(std::random_access_iterator<CRI>);
+ static_assert(!std::contiguous_iterator<I>);
+ static_assert(!std::contiguous_iterator<CI>);
+ static_assert(!std::contiguous_iterator<RI>);
+ static_assert(!std::contiguous_iterator<CRI>);
+ static_assert(!std::indirectly_writable<I, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<CI, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<RI, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<CRI, std::pair<int, char>>);
+ static_assert( std::sentinel_for<I, I>);
+ static_assert( std::sentinel_for<I, CI>);
+ static_assert(!std::sentinel_for<I, RI>);
+ static_assert(!std::sentinel_for<I, CRI>);
+ static_assert( std::sentinel_for<CI, I>);
+ static_assert( std::sentinel_for<CI, CI>);
+ static_assert(!std::sentinel_for<CI, RI>);
+ static_assert(!std::sentinel_for<CI, CRI>);
+ static_assert(!std::sentinel_for<RI, I>);
+ static_assert(!std::sentinel_for<RI, CI>);
+ static_assert( std::sentinel_for<RI, RI>);
+ static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(!std::sentinel_for<CRI, I>);
+ static_assert(!std::sentinel_for<CRI, CI>);
+ static_assert( std::sentinel_for<CRI, RI>);
+ static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::indirectly_movable_storable<I, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<CI, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<RI, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<CRI, std::pair<int, char>*>);
+ }
+ {
+ using C = std::flat_map<char*, int, std::less<>, std::deque<char*>, std::vector<int>>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
+ using CRI = C::const_reverse_iterator;
+ static_assert(std::random_access_iterator<I>);
+ static_assert(std::random_access_iterator<CI>);
+ static_assert(std::random_access_iterator<RI>);
+ static_assert(std::random_access_iterator<CRI>);
+ static_assert(!std::contiguous_iterator<I>);
+ static_assert(!std::contiguous_iterator<CI>);
+ static_assert(!std::contiguous_iterator<RI>);
+ static_assert(!std::contiguous_iterator<CRI>);
+ static_assert(!std::indirectly_writable<I, std::pair<char*, int>>);
+ static_assert(!std::indirectly_writable<CI, std::pair<char*, int>>);
+ static_assert(!std::indirectly_writable<RI, std::pair<char*, int>>);
+ static_assert(!std::indirectly_writable<CRI, std::pair<char*, int>>);
+ static_assert( std::sentinel_for<I, I>);
+ static_assert( std::sentinel_for<I, CI>);
+ static_assert(!std::sentinel_for<I, RI>);
+ static_assert(!std::sentinel_for<I, CRI>);
+ static_assert( std::sentinel_for<CI, I>);
+ static_assert( std::sentinel_for<CI, CI>);
+ static_assert(!std::sentinel_for<CI, RI>);
+ static_assert(!std::sentinel_for<CI, CRI>);
+ static_assert(!std::sentinel_for<RI, I>);
+ static_assert(!std::sentinel_for<RI, CI>);
+ static_assert( std::sentinel_for<RI, RI>);
+ static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(!std::sentinel_for<CRI, I>);
+ static_assert(!std::sentinel_for<CRI, CI>);
+ static_assert( std::sentinel_for<CRI, RI>);
+ static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::indirectly_movable_storable<I, std::pair<char*, int>*>);
+ static_assert(std::indirectly_movable_storable<CI, std::pair<char*, int>*>);
+ static_assert(std::indirectly_movable_storable<RI, std::pair<char*, int>*>);
+ static_assert(std::indirectly_movable_storable<CRI, std::pair<char*, int>*>);
+ }
+ {
+ using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
+ using CRI = C::const_reverse_iterator;
+ static_assert(std::random_access_iterator<I>);
+ static_assert(std::random_access_iterator<CI>);
+ static_assert(std::random_access_iterator<RI>);
+ static_assert(std::random_access_iterator<CRI>);
+ static_assert(!std::contiguous_iterator<I>);
+ static_assert(!std::contiguous_iterator<CI>);
+ static_assert(!std::contiguous_iterator<RI>);
+ static_assert(!std::contiguous_iterator<CRI>);
+ static_assert(!std::indirectly_writable<I, std::pair<char, bool>>);
+ static_assert(!std::indirectly_writable<CI, std::pair<char, bool>>);
+ static_assert(!std::indirectly_writable<RI, std::pair<char, bool>>);
+ static_assert(!std::indirectly_writable<CRI, std::pair<char, bool>>);
+ static_assert( std::sentinel_for<I, I>);
+ static_assert( std::sentinel_for<I, CI>);
+ static_assert(!std::sentinel_for<I, RI>);
+ static_assert(!std::sentinel_for<I, CRI>);
+ static_assert( std::sentinel_for<CI, I>);
+ static_assert( std::sentinel_for<CI, CI>);
+ static_assert(!std::sentinel_for<CI, RI>);
+ static_assert(!std::sentinel_for<CI, CRI>);
+ static_assert(!std::sentinel_for<RI, I>);
+ static_assert(!std::sentinel_for<RI, CI>);
+ static_assert( std::sentinel_for<RI, RI>);
+ static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(!std::sentinel_for<CRI, I>);
+ static_assert(!std::sentinel_for<CRI, CI>);
+ static_assert( std::sentinel_for<CRI, RI>);
+ static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::indirectly_movable_storable<I, std::pair<char, bool>*>);
+ static_assert(std::indirectly_movable_storable<CI, std::pair<char, bool>*>);
+ static_assert(std::indirectly_movable_storable<RI, std::pair<char, bool>*>);
+ static_assert(std::indirectly_movable_storable<CRI, std::pair<char, bool>*>);
+ }
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
new file mode 100644
index 00000000000000..8094e7771fc604
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator lower_bound(const key_type& k);
+// const_iterator lower_bound(const key_type& k) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
+ assert(m.lower_bound(0) == m.begin());
+ assert(m.lower_bound(1) == m.begin());
+ assert(m.lower_bound(2) == m.begin() + 1);
+ assert(m.lower_bound(3) == m.begin() + 2);
+ assert(m.lower_bound(4) == m.begin() + 2);
+ assert(m.lower_bound(5) == m.begin() + 3);
+ assert(m.lower_bound(6) == m.begin() + 4);
+ assert(m.lower_bound(7) == m.begin() + 4);
+ assert(std::as_const(m).lower_bound(8) == m.begin() + 4);
+ assert(std::as_const(m).lower_bound(9) == m.end());
+ }
+ {
+ using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
+ assert(m.lower_bound(0) == m.end());
+ assert(m.lower_bound(1) == m.begin() + 4);
+ assert(m.lower_bound(2) == m.begin() + 3);
+ assert(m.lower_bound(3) == m.begin() + 3);
+ assert(m.lower_bound(4) == m.begin() + 2);
+ assert(m.lower_bound(5) == m.begin() + 1);
+ assert(m.lower_bound(6) == m.begin() + 1);
+ assert(m.lower_bound(7) == m.begin() + 1);
+ assert(std::as_const(m).lower_bound(8) == m.begin());
+ assert(std::as_const(m).lower_bound(9) == m.begin());
+ }
+ {
+ using M = std::flat_map<bool, bool>;
+ M m = {{true,false}, {false,true}};
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
+ assert(m.lower_bound(true) == m.begin() + 1);
+ assert(m.lower_bound(false) == m.begin());
+ m = {{true,true}};
+ assert(m.lower_bound(true) == m.begin());
+ assert(m.lower_bound(false) == m.begin());
+ m = {{false,false}};
+ assert(std::as_const(m).lower_bound(true) == m.end());
+ assert(std::as_const(m).lower_bound(false) == m.begin());
+ m.clear();
+ assert(m.lower_bound(true) == m.end());
+ assert(m.lower_bound(false) == m.end());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
new file mode 100644
index 00000000000000..a391d099f3addf
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator lower_bound(const K& x);
+// template<class K> const_iterator lower_bound(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(StartsWith('b'))), M::const_iterator);
+ assert(m.lower_bound("beta") == m.begin() + 1);
+ assert(m.lower_bound("delta") == m.begin() + 2);
+ assert(m.lower_bound("zeta") == m.begin() + 5);
+ assert(m.lower_bound(StartsWith('b')) == m.begin() + 1);
+ assert(m.lower_bound(StartsWith('d')) == m.begin() + 2);
+ assert(m.lower_bound(StartsWith('e')) == m.begin() + 2);
+ assert(m.lower_bound(StartsWith('z')) == m.begin() + 5);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
new file mode 100644
index 00000000000000..1c21704ebd64c1
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// size_type max_size() const noexcept;
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <limits>
+#include <type_traits>
+#include <vector>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ {
+ using A1 = limited_allocator<int, 10>;
+ using A2 = limited_allocator<int, 20>;
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int, A1>, std::vector<int, A2>>;
+ ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
+ ASSERT_SAME_TYPE(C::size_type, std::size_t);
+ C c;
+ ASSERT_NOEXCEPT(c.max_size());
+ ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
+ assert(c.max_size() <= 10);
+ LIBCPP_ASSERT(c.max_size() == 10);
+ }
+ {
+ using A1 = limited_allocator<int, 10>;
+ using A2 = limited_allocator<int, 20>;
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int, A2>, std::vector<int, A1>>;
+ ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
+ ASSERT_SAME_TYPE(C::size_type, std::size_t);
+ C c;
+ ASSERT_NOEXCEPT(c.max_size());
+ ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
+ assert(c.max_size() <= 10);
+ LIBCPP_ASSERT(c.max_size() == 10);
+ }
+ {
+ using A = limited_allocator<int, (size_t)-1>;
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::vector<int, A>>;
+ ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
+ ASSERT_SAME_TYPE(C::size_type, std::size_t);
+ const C::size_type max_dist =
+ static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
+ C c;
+ ASSERT_NOEXCEPT(c.max_size());
+ ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
+ assert(c.max_size() <= max_dist);
+ LIBCPP_ASSERT(c.max_size() == max_dist);
+ }
+ {
+ typedef std::flat_map<char, char> C;
+ ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
+ ASSERT_SAME_TYPE(C::size_type, std::size_t);
+ const C::size_type max_dist =
+ static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
+ C c;
+ ASSERT_NOEXCEPT(c.max_size());
+ ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
+ assert(c.max_size() <= max_dist);
+ assert(c.max_size() <= alloc_max_size(std::allocator<char>()));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
new file mode 100644
index 00000000000000..586933c6403607
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// friend bool operator==(const flat_map& x, const flat_map& y);
+// friend synth-three-way-result<value_type>
+// operator<=>(const flat_map& x, const flat_map& y);
+
+#include <algorithm>
+#include <cassert>
+#include <compare>
+#include <flat_map>
+#include <functional>
+#include <limits>
+
+#include "test_comparisons.h"
+#include "test_container_comparisons.h"
+
+int main(int, char**) {
+ {
+ using C = std::flat_map<int, int>;
+ C s1 = {{1,1}};
+ C s2 = {{2,0}}; // {{1,1}} versus {{2,0}}
+ ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering);
+ AssertComparisonsReturnBool<C>();
+ assert(testComparisons(s1, s2, false, true));
+ s2 = {{1,1}}; // {{1,1}} versus {{1,1}}
+ assert(testComparisons(s1, s2, true, false));
+ s2 = {{1,1},{2,0}}; // {{1,1}} versus {{1,1},{2,0}}
+ assert(testComparisons(s1, s2, false, true));
+ s1 = {{0,0},{1,1},{2,2}}; // {{0,0},{1,1},{2,2}} versus {{1,1},{2,0}}
+ assert(testComparisons(s1, s2, false, true));
+ s2 = {{0,0},{1,1},{2,3}}; // {{0,0},{1,1},{2,2}} versus {{0,0},{1,1},{2,3}}
+ assert(testComparisons(s1, s2, false, true));
+ }
+ {
+ // Comparisons use value_type's native operators, not the comparator
+ using C = std::flat_map<int, int, std::greater<int>>;
+ C s1 = {{1,1}};
+ C s2 = {{2,0}}; // {{1,1}} versus {{2,0}}
+ ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering);
+ AssertComparisonsReturnBool<C>();
+ assert(testComparisons(s1, s2, false, true));
+ s2 = {{1,1}}; // {{1,1}} versus {{1,1}}
+ assert(testComparisons(s1, s2, true, false));
+ s2 = {{1,1},{2,0}}; // {{1,1}} versus {{2,0},{1,1}}
+ assert(testComparisons(s1, s2, false, true));
+ s1 = {{0,0},{1,1},{2,2}}; // {{2,2},{1,1},{0,0}} versus {2,0},{1,1}}
+ assert(testComparisons(s1, s2, false, false));
+ s2 = {{0,0},{1,1},{2,3}}; // {{2,2},{1,1},{0,0}} versus {{2,3},{1,1},{0,0}}
+ assert(testComparisons(s1, s2, false, true));
+ }
+ {
+ using C = std::flat_map<double, int>;
+ C s1 = { {1, 1} };
+ C s2 = C(std::sorted_unique, { {std::numeric_limits<double>::quiet_NaN(), 2} });
+ ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
+ AssertComparisonsReturnBool<C>();
+ assert(testComparisonsComplete(s1, s2, false, false, false));
+ }
+ {
+ using C = std::flat_map<int, double>;
+ C s1 = { {1, 1} };
+ C s2 = C(std::sorted_unique, { {2, std::numeric_limits<double>::quiet_NaN()} });
+ ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
+ AssertComparisonsReturnBool<C>();
+ assert(testComparisonsComplete(s1, s2, false, true, false));
+ s2 = C(std::sorted_unique, { {1, std::numeric_limits<double>::quiet_NaN()} });
+ assert(testComparisonsComplete(s1, s2, false, false, false));
+ }
+ {
+ // Comparisons use value_type's native operators, not the comparator
+ struct StrongComp {
+ bool operator()(double a, double b) const { return std::strong_order(a, b) < 0; }
+ };
+ using C = std::flat_map<double, double, StrongComp>;
+ C s1 = {{1, 1}};
+ C s2 = { {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()} };
+ ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
+ AssertComparisonsReturnBool<C>();
+ assert(testComparisonsComplete(s1, s2, false, false, false));
+ s1 = { { {1, 1}, {std::numeric_limits<double>::quiet_NaN(), 1} } };
+ s2 = { { {std::numeric_limits<double>::quiet_NaN(), 1}, {1, 1} } };
+ assert(std::lexicographical_compare_three_way(s1.keys().begin(), s1.keys().end(), s2.keys().begin(), s2.keys().end(), std::strong_order) == std::strong_ordering::equal);
+ assert(s1 != s2);
+ assert((s1 <=> s2) == std::partial_ordering::unordered);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp
new file mode 100644
index 00000000000000..981267f6604a02
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <ranges>
+#include <string>
+#include <vector>
+
+void test() {
+ {
+ using C = std::flat_map<int, int, std::deque<int>, std::vector<int>>;
+
+ static_assert(std::same_as<std::ranges::iterator_t<C>, C::iterator>);
+ static_assert(std::ranges::random_access_range<C>);
+ static_assert(!std::ranges::contiguous_range<C>);
+ static_assert(std::ranges::common_range<C>);
+ static_assert(std::ranges::input_range<C>);
+ static_assert(!std::ranges::view<C>);
+ static_assert(std::ranges::sized_range<C>);
+ static_assert(!std::ranges::borrowed_range<C>);
+ static_assert(std::ranges::viewable_range<C>);
+
+ static_assert(std::same_as<std::ranges::iterator_t<const C>, C::const_iterator>);
+ static_assert(std::ranges::random_access_range<const C>);
+ static_assert(!std::ranges::contiguous_range<const C>);
+ static_assert(std::ranges::common_range<const C>);
+ static_assert(std::ranges::input_range<const C>);
+ static_assert(!std::ranges::view<const C>);
+ static_assert(std::ranges::sized_range<const C>);
+ static_assert(!std::ranges::borrowed_range<const C>);
+ static_assert(!std::ranges::viewable_range<const C>);
+ }
+ {
+ using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
+
+ static_assert(std::same_as<std::ranges::iterator_t<C>, C::iterator>);
+ static_assert(std::ranges::random_access_range<C>);
+ static_assert(!std::ranges::contiguous_range<C>);
+ static_assert(std::ranges::common_range<C>);
+ static_assert(std::ranges::input_range<C>);
+ static_assert(!std::ranges::view<C>);
+ static_assert(std::ranges::sized_range<C>);
+ static_assert(!std::ranges::borrowed_range<C>);
+ static_assert(std::ranges::viewable_range<C>);
+
+ static_assert(std::same_as<std::ranges::iterator_t<const C>, C::const_iterator>);
+ static_assert(std::ranges::random_access_range<const C>);
+ static_assert(!std::ranges::contiguous_range<const C>);
+ static_assert(std::ranges::common_range<const C>);
+ static_assert(std::ranges::input_range<const C>);
+ static_assert(!std::ranges::view<const C>);
+ static_assert(std::ranges::sized_range<const C>);
+ static_assert(!std::ranges::borrowed_range<const C>);
+ static_assert(!std::ranges::viewable_range<const C>);
+ }
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
new file mode 100644
index 00000000000000..3afdb56d48e28d
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// reverse_iterator rbegin();
+// const_reverse_iterator rbegin() const;
+// reverse_iterator rend();
+// const_reverse_iterator rend() const;
+//
+// const_reverse_iterator crbegin() const;
+// const_reverse_iterator crend() const;
+
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <string>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
+ M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ ASSERT_SAME_TYPE(decltype(m.rbegin()), M::reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.rend()), M::reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.crend()), M::const_reverse_iterator);
+ assert(m.size() == 4);
+ assert(std::distance(m.rbegin(), m.rend()) == 4);
+ assert(std::distance(m.crbegin(), m.crend()) == 4);
+ M::reverse_iterator i; // default-construct
+ ASSERT_SAME_TYPE(decltype(i->first), const int&);
+ ASSERT_SAME_TYPE(decltype(i->second), char&);
+ i = m.rbegin(); // move-assignment
+ M::const_reverse_iterator k = i; // converting constructor
+ assert(i == k); // comparison
+ for (int j = 4; j >= 1; --j, ++i) { // pre-increment
+ assert(i->first == j); // operator->
+ assert(i->second == 'a' + j - 1);
+ }
+ assert(i == m.rend());
+ for (int j = 1; j <= 4; ++j) {
+ --i; // pre-decrement
+ assert((*i).first == j);
+ assert((*i).second == 'a' + j - 1);
+ }
+ assert(i == m.rbegin());
+ }
+ {
+ using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
+ const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ ASSERT_SAME_TYPE(decltype(m.rbegin()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.rend()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(m.crend()), M::const_reverse_iterator);
+ assert(m.size() == 4);
+ assert(std::distance(m.rbegin(), m.rend()) == 4);
+ assert(std::distance(m.crbegin(), m.crend()) == 4);
+ M::const_reverse_iterator i; // default-construct
+ ASSERT_SAME_TYPE(decltype(i->first), const short&);
+ ASSERT_SAME_TYPE(decltype(i->second), const char&);
+ i = m.rbegin(); // move-assignment
+ for (int j = 4; j >= 1; --j, ++i) { // pre-increment
+ assert(i->first == j);
+ assert(i->second == 'a' + j - 1);
+ }
+ assert(i == m.rend());
+ for (int j = 1; j <= 4; ++j) {
+ --i; // pre-decrement
+ assert((*i).first == j);
+ assert((*i).second == 'a' + j - 1);
+ }
+ assert(i == m.rbegin());
+ }
+ {
+ // N3644 testing
+ using C = std::flat_map<int, char>;
+ C::reverse_iterator ii1{}, ii2{};
+ C::reverse_iterator ii4 = ii1;
+ C::const_reverse_iterator cii{};
+ assert(ii1 == ii2);
+ assert(ii1 == ii4);
+ assert(!(ii1 != ii2));
+
+ assert( (ii1 == cii));
+ assert( (cii == ii1));
+ assert(!(ii1 != cii));
+ assert(!(cii != ii1));
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
new file mode 100644
index 00000000000000..d3aba8b14172e0
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class Key, class T, class Compare = less<Key>,
+// class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+// class flat_map {
+// public:
+// // types
+// using key_type = Key;
+// using mapped_type = T;
+// using value_type = pair<key_type, mapped_type>;
+// using key_compare = Compare;
+// using reference = pair<const key_type&, mapped_type&>;
+// using const_reference = pair<const key_type&, const mapped_type&>;
+// using size_type = size_t;
+// using difference_type = ptrdiff_t;
+// using iterator = implementation-defined; // see [container.requirements]
+// using const_iterator = implementation-defined; // see [container.requirements]
+// using reverse_iterator = std::reverse_iterator<iterator>;
+// using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+// using key_container_type = KeyContainer;
+// using mapped_container_type = MappedContainer;
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using C = std::flat_map<int, short>;
+ static_assert(std::is_same_v<C::key_type, int>);
+ static_assert(std::is_same_v<C::mapped_type, short>);
+ static_assert(std::is_same_v<C::value_type, std::pair<int, short>>);
+ static_assert(std::is_same_v<C::key_compare, std::less<int>>);
+ static_assert(!std::is_same_v<C::value_compare, std::less<int>>);
+ static_assert(std::is_same_v<C::reference, std::pair<const int&, short&>>);
+ static_assert(std::is_same_v<C::const_reference, std::pair<const int&, const short&>>);
+ static_assert(std::random_access_iterator<C::iterator>);
+ static_assert(std::random_access_iterator<C::const_iterator>);
+ static_assert(std::random_access_iterator<C::reverse_iterator>);
+ static_assert(std::random_access_iterator<C::const_reverse_iterator>);
+ static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
+ static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
+ static_assert(std::is_same_v<C::size_type, std::size_t>);
+ static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
+ static_assert(std::is_same_v<C::key_container_type, std::vector<int>>);
+ static_assert(std::is_same_v<C::mapped_container_type, std::vector<short>>);
+ }
+ {
+ using C = std::flat_map<short, int, std::greater<long>, std::deque<short, min_allocator<short>>>;
+ static_assert(std::is_same_v<C::key_type, short>);
+ static_assert(std::is_same_v<C::mapped_type, int>);
+ static_assert(std::is_same_v<C::value_type, std::pair<short, int>>);
+ static_assert(std::is_same_v<C::key_compare, std::greater<long>>);
+ static_assert(!std::is_same_v<C::value_compare, std::greater<long>>);
+ static_assert(std::is_same_v<C::reference, std::pair<const short&, int&>>);
+ static_assert(std::is_same_v<C::const_reference, std::pair<const short&, const int&>>);
+ static_assert(std::random_access_iterator<C::iterator>);
+ static_assert(std::random_access_iterator<C::const_iterator>);
+ static_assert(std::random_access_iterator<C::reverse_iterator>);
+ static_assert(std::random_access_iterator<C::const_reverse_iterator>);
+ static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
+ static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
+ // size_type is invariably size_t
+ static_assert(std::is_same_v<C::size_type, std::size_t>);
+ static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
+ static_assert(std::is_same_v<C::key_container_type, std::deque<short, min_allocator<short>>>);
+ static_assert(std::is_same_v<C::mapped_container_type, std::vector<int>>);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
new file mode 100644
index 00000000000000..76238c16b1129e
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator upper_bound(const key_type& k);
+// const_iterator upper_bound(const key_type& k) const;
+
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<int, char>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
+ assert(m.upper_bound(0) == m.begin());
+ assert(m.upper_bound(1) == m.begin() + 1);
+ assert(m.upper_bound(2) == m.begin() + 2);
+ assert(m.upper_bound(3) == m.begin() + 2);
+ assert(m.upper_bound(4) == m.begin() + 3);
+ assert(m.upper_bound(5) == m.begin() + 4);
+ assert(m.upper_bound(6) == m.begin() + 4);
+ assert(std::as_const(m).upper_bound(7) == m.begin() + 4);
+ assert(std::as_const(m).upper_bound(8) == m.end());
+ assert(std::as_const(m).upper_bound(9) == m.end());
+ }
+ {
+ using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
+ M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
+ assert(m.upper_bound(0) == m.end());
+ assert(m.upper_bound(1) == m.end());
+ assert(m.upper_bound(2) == m.begin() + 4);
+ assert(m.upper_bound(3) == m.begin() + 3);
+ assert(m.upper_bound(4) == m.begin() + 3);
+ assert(m.upper_bound(5) == m.begin() + 2);
+ assert(m.upper_bound(6) == m.begin() + 1);
+ assert(m.upper_bound(7) == m.begin() + 1);
+ assert(std::as_const(m).upper_bound(8) == m.begin() + 1);
+ assert(std::as_const(m).upper_bound(9) == m.begin());
+ }
+ {
+ using M = std::flat_map<bool, bool>;
+ M m = {{true,false}, {false,true}};
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
+ assert(m.upper_bound(true) == m.end());
+ assert(m.upper_bound(false) == m.begin() + 1);
+ m = {{true,true}};
+ assert(m.upper_bound(true) == m.end());
+ assert(m.upper_bound(false) == m.begin());
+ m = {{false,false}};
+ assert(std::as_const(m).upper_bound(true) == m.end());
+ assert(std::as_const(m).upper_bound(false) == m.end());
+ m.clear();
+ assert(m.upper_bound(true) == m.end());
+ assert(m.upper_bound(false) == m.end());
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
new file mode 100644
index 00000000000000..745a250c068fa1
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator upper_bound(const K& x);
+// template<class K> const_iterator upper_bound(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ };
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+int main(int, char**)
+{
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(StartsWith('b'))), M::const_iterator);
+ assert(m.upper_bound("beta") == m.begin() + 2);
+ assert(m.upper_bound("delta") == m.begin() + 2);
+ assert(m.upper_bound("zeta") == m.begin() + 5);
+ assert(m.upper_bound(StartsWith('b')) == m.begin() + 2);
+ assert(m.upper_bound(StartsWith('d')) == m.begin() + 2);
+ assert(m.upper_bound(StartsWith('e')) == m.begin() + 4);
+ assert(m.upper_bound(StartsWith('z')) == m.begin() + 5);
+ }
+ return 0;
+}
>From d04e5eb0d6f39d282c5a0d7889927c1c24b3f84f Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 31 Jul 2024 18:09:28 +0100
Subject: [PATCH 03/40] more fixes
---
libcxx/include/__flat_map/flat_map.h | 116 ++++++++++++++----
.../flat.map/contains_transparent.pass.cpp | 21 +---
.../flat.map/count_transparent.pass.cpp | 21 +---
.../flat.map/equal_range_transparent.pass.cpp | 39 ++----
.../flat.map/erase_key_transparent.pass.cpp | 75 +++++------
.../container.adaptors/flat.map/find.pass.cpp | 15 ++-
.../flat.map/find_transparent.pass.cpp | 23 +---
.../container.adaptors/flat.map/helpers.h | 35 ++++++
.../flat.map/iterator.pass.cpp | 26 ++--
.../flat.map/iterator_comparison.pass.cpp | 18 +--
.../flat.map/lower_bound_transparent.pass.cpp | 21 +---
.../flat.map/op_compare.pass.cpp | 1 +
.../flat.map/reverse_iterator.pass.cpp | 29 +++--
.../flat.map/upper_bound_transparent.pass.cpp | 21 +---
libcxx/test/support/MinSequenceContainer.h | 81 ++++++++++++
15 files changed, 316 insertions(+), 226 deletions(-)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
create mode 100644 libcxx/test/support/MinSequenceContainer.h
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index dc75ea6d64f8d7..de08cf6a0a1814 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -9,9 +9,10 @@
#ifndef _LIBCPP___FLAT_MAP_FLAT_MAP_H
#define _LIBCPP___FLAT_MAP_FLAT_MAP_H
+#include <__algorithm/lexicographical_compare_three_way.h>
#include <__algorithm/ranges_equal.h>
-#include <__algorithm/ranges_lexicographical_compare.h>
#include <__algorithm/ranges_lower_bound.h>
+#include <__algorithm/ranges_partition_point.h>
#include <__algorithm/ranges_stable_sort.h>
#include <__algorithm/ranges_unique.h>
#include <__algorithm/ranges_upper_bound.h>
@@ -19,6 +20,7 @@
#include <__concepts/convertible_to.h>
#include <__config>
#include <__flat_map/sorted_unique.h>
+#include <__functional/invoke.h>
#include <__functional/is_transparent.h>
#include <__functional/operations.h>
#include <__iterator/concepts.h>
@@ -37,7 +39,7 @@
#include <__type_traits/conjunction.h>
#include <__type_traits/invoke.h>
#include <__type_traits/is_allocator.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
#include <__type_traits/maybe_const.h>
#include <__utility/pair.h>
#include <initializer_list>
@@ -113,7 +115,7 @@ class flat_map {
template <bool _Const>
struct __iterator {
private:
- using __key_iterator = ranges::iterator_t<__maybe_const<_Const, key_container_type>>;
+ using __key_iterator = ranges::iterator_t<const key_container_type>;
using __mapped_iterator = ranges::iterator_t<__maybe_const<_Const, mapped_container_type>>;
using __reference = pair<iter_reference_t<__key_iterator>, iter_reference_t<__mapped_iterator>>;
@@ -177,8 +179,8 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI __iterator& operator-=(difference_type __x) {
- __key_iter_ += __x;
- __mapped_iter_ += __x;
+ __key_iter_ -= __x;
+ __mapped_iter_ -= __x;
return *this;
}
@@ -704,11 +706,11 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
- return __erase_impl(__position.__key_iter_, __position.__mapped_iter);
+ return __erase_impl(__position.__key_iter_, __position.__mapped_iter_);
}
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position) {
- return __erase_impl(__position.__key_iter_, __position.__mapped_iter);
+ return __erase_impl(__position.__key_iter_, __position.__mapped_iter_);
}
_LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) {
@@ -721,22 +723,21 @@ class flat_map {
}
template <class _Kp>
- requires __is_compare_transparent
+ requires(__is_compare_transparent && !is_convertible_v<_Kp &&, iterator> &&
+ !is_convertible_v<_Kp &&, const_iterator>)
_LIBCPP_HIDE_FROM_ABI size_type erase(_Kp&& __x) {
- auto __iter = find(__x);
- if (__iter != end()) {
- erase(__iter);
- return 1;
- }
- return 0;
+ auto [__first, __last] = equal_range(__x);
+ auto __res = __last - __first;
+ erase(__first, __last);
+ return __res;
}
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- auto __key_it = __containers_.keys.erase(__first.__key_iter, __last.__key_iter);
- auto __mapped_it = __containers_.values.erase(__first.__mapped_iter, __last.__mapped_iter);
+ auto __key_it = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_);
+ auto __mapped_it = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_);
return iterator(std::move(__key_it), std::move(__mapped_it));
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (const exception& __ex) {
@@ -803,8 +804,10 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __x) const { return contains(__x) ? 1 : 0; }
template <class _Kp>
+ requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const {
- return contains(__x) ? 1 : 0;
+ auto [__first, __last] = __equal_range_return_key_iter(*this, __x);
+ return __last - __first;
}
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
@@ -873,9 +876,9 @@ class flat_map {
return ranges::equal(__x, __y);
}
- friend _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<value_type>
- operator<=>(const flat_map& __x, const flat_map& __y) {
- return ranges::lexicographical_compare(__x, __y);
+ friend _LIBCPP_HIDE_FROM_ABI auto operator<=>(const flat_map& __x, const flat_map& __y) {
+ return std::lexicographical_compare_three_way(
+ __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
}
friend _LIBCPP_HIDE_FROM_ABI void swap(flat_map& __x, flat_map& __y) noexcept { __x.swap(__y); }
@@ -925,16 +928,48 @@ class flat_map {
return __it;
}
- template <class _Self, class _Kp>
- _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
- auto __it = __self.lower_bound(__key);
- auto __last = __self.end();
- if (__it == __last || __self.__compare_(__key, __it->first)) {
- return std::make_pair(std::move(__it), std::move(__last));
+ template <class _Self>
+ _LIBCPP_HIDE_FROM_ABI static auto __equal_range_return_key_iter(_Self&& __self, const _Key& __key) {
+ auto __it = ranges::lower_bound(__self.__containers_.keys, __key, __self.__compare_);
+ auto __last = __self.__containers_.keys.end();
+ if (__it == __last || __self.__compare_(__key, *__it)) {
+ return std::make_pair(__it, __it);
}
return std::make_pair(__it, std::next(__it));
}
+ template <class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static auto __equal_range_return_key_iter(_Self&& __self, const _Kp& __key) {
+ // if the comparator gives different results between Key(__x) < key2 and __x < key2,
+ // the container might have duplicates w.r.t to _Kp < Key
+ // TODO: this is the case in Author's test case, but do we really want to support it?
+ auto __first_not_smaller = ranges::lower_bound(__self.__containers_.keys, __key, __self.__compare_);
+ auto __first_bigger =
+ std::ranges::partition_point(__first_not_smaller, __self.__containers_.keys.end(), [&](const auto& __ele) {
+ return !std::invoke(__self.__compare_, __key, __ele);
+ });
+ return std::make_pair(std::move(__first_not_smaller), std::move(__first_bigger));
+ }
+
+ template <class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
+ // if the comparator gives different results between Key(__x) < key2 and __x < key2,
+ // the container might have duplicates w.r.t to _Kp < Key
+ // TODO: this is the case in Author's test case, but do we really want to support it?
+ auto [__first_not_smaller_key_iter, __first_bigger_key_iter] = __equal_range_return_key_iter(__self, __key);
+
+ const auto __make_mapped_iter = [&](const auto& __key_iter) {
+ return __self.__containers_.values.begin() +
+ static_cast<ranges::range_difference_t<mapped_container_type>>(
+ ranges::distance(__self.__containers_.keys.begin(), __key_iter));
+ };
+
+ using __iterator_type = ranges::iterator_t<decltype(__self)>;
+ return std::make_pair(
+ __iterator_type(__first_not_smaller_key_iter, __make_mapped_iter(__first_not_smaller_key_iter)),
+ __iterator_type(__first_bigger_key_iter, __make_mapped_iter(__first_bigger_key_iter)));
+ }
+
template <class _Res, class _Self, class _Kp>
_LIBCPP_HIDE_FROM_ABI static _Res __lower_bound_impl(_Self&& __self, _Kp& __x) {
return __binary_search_impl<_Res>(ranges::lower_bound, __self, __x);
@@ -950,7 +985,7 @@ class flat_map {
if (__hint != cbegin() && !__compare_(std::prev(__hint)->first, __key)) {
return false;
}
- if (__hint != cend() && __compare(__hint->first, __key)) {
+ if (__hint != cend() && __compare_(__hint->first, __key)) {
return false;
}
return true;
@@ -1168,6 +1203,10 @@ class flat_map {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
+ template <class _Key2, class _Tp2, class _Compare2, class _KeyContainer2, class _MappedContainer2, class _Predicate>
+ friend typename flat_map<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>::size_type
+ erase_if(flat_map<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate);
+
containers __containers_;
[[no_unique_address]] key_compare __compare_;
@@ -1296,6 +1335,29 @@ template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _Map
struct uses_allocator<flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
: bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
+template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _MappedContainer, class _Predicate>
+_LIBCPP_HIDE_FROM_ABI typename flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::size_type
+erase_if(flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_map, _Predicate __pred) {
+ auto __zv = ranges::views::zip(__flat_map.__containers_.keys, __flat_map.__containers_.values);
+ auto __first = __zv.begin();
+ auto __last = __zv.end();
+ auto __guard = std::__make_exception_guard([&] { __flat_map.clear(); });
+ auto __it = std::remove_if(__first, __last, [&](auto&& __zipped) -> bool {
+ using __ref = typename flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::const_reference;
+ return __pred(__ref(std::get<0>(__zipped), std::get<1>(__zipped)));
+ });
+ auto __res = __last - __it;
+ auto __offset = __it - __first;
+
+ const auto __erase_container = [&](auto& __cont) { __cont.erase(__cont.begin() + __offset, __cont.end()); };
+
+ __erase_container(__flat_map.__containers_.keys);
+ __erase_container(__flat_map.__containers_.values);
+
+ __guard.__complete();
+ return __res;
+}
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER >= 23
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
index 0c4c9fcefad8a0..672e9245884413 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
@@ -17,28 +17,13 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.contains(StartsWith('b'))), bool);
ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(StartsWith('b'))), bool);
assert(m.contains("beta") == true);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
index 2ca6bd9ec15ded..be9751ecec6466 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
@@ -17,28 +17,13 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.count(StartsWith('b'))), M::size_type);
ASSERT_SAME_TYPE(decltype(std::as_const(m).count(StartsWith('b'))), M::size_type);
assert(m.count("beta") == 1);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
index ee6bc7ef8868f9..fe0ccc9237bc72 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
@@ -18,40 +18,25 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- using R = std::pair<M::iterator, M::iterator>;
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ using R = std::pair<M::iterator, M::iterator>;
using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.equal_range(StartsWith('b'))), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(StartsWith('b'))), CR);
auto begin = m.begin();
- assert(m.equal_range("beta") == std::pair(begin+1, begin+2));
- assert(m.equal_range("delta") == std::pair(begin+2, begin+2));
- assert(m.equal_range("zeta") == std::pair(begin+5, begin+5));
- assert(m.equal_range(StartsWith('b')) == std::pair(begin+1, begin+2));
- assert(m.equal_range(StartsWith('d')) == std::pair(begin+2, begin+2));
- assert(m.equal_range(StartsWith('e')) == std::pair(begin+2, begin+4));
- assert(m.equal_range(StartsWith('z')) == std::pair(begin+5, begin+5));
+ assert(m.equal_range("beta") == std::pair(begin + 1, begin + 2));
+ assert(m.equal_range("delta") == std::pair(begin + 2, begin + 2));
+ assert(m.equal_range("zeta") == std::pair(begin + 5, begin + 5));
+ assert(m.equal_range(StartsWith('b')) == std::pair(begin + 1, begin + 2));
+ assert(m.equal_range(StartsWith('d')) == std::pair(begin + 2, begin + 2));
+ assert(m.equal_range(StartsWith('e')) == std::pair(begin + 2, begin + 4));
+ assert(m.equal_range(StartsWith('z')) == std::pair(begin + 5, begin + 5));
}
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
index cad13d18f1fec2..f533b85c37a463 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
@@ -20,100 +20,89 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
-template<class Key, class It>
+template <class Key, class It>
struct HeterogeneousKey {
explicit HeterogeneousKey(Key key, It it) : key_(key), it_(it) {}
operator It() && { return it_; }
auto operator<=>(Key key) const { return key_ <=> key; }
+ friend bool operator<(const HeterogeneousKey&, const HeterogeneousKey&) {
+ assert(false);
+ return false;
+ }
Key key_;
It it_;
};
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.erase(StartsWith('b'))), M::size_type);
M::size_type n = m.erase(StartsWith('e'));
assert(n == 2);
- assert((m == M{ {"alpha", 1}, {"beta", 2}, {"gamma", 5} }));
+ assert((m == M{{"alpha", 1}, {"beta", 2}, {"gamma", 5}}));
n = m.erase(StartsWith('d'));
assert(n == 0);
- assert((m == M{ {"alpha", 1}, {"beta", 2}, {"gamma", 5} }));
+ assert((m == M{{"alpha", 1}, {"beta", 2}, {"gamma", 5}}));
}
{
using M = std::flat_map<int, int, std::less<>>;
- M m = {{1,1}, {2,2}, {3,3}, {4,4}};
+ M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
auto n = m.erase(3); // erase(K&&) [with K=int]
assert(n == 1);
- assert((m == M{{1,1}, {2,2}, {4,4}}));
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}}));
M::key_type lvalue = 2;
- n = m.erase(lvalue); // erase(K&&) [with K=int&]
+ n = m.erase(lvalue); // erase(K&&) [with K=int&]
assert(n == 1);
- assert((m == M{{1,1}, {4,4}}));
+ assert((m == M{{1, 1}, {4, 4}}));
const M::key_type const_lvalue = 1;
- n = m.erase(const_lvalue); // erase(const key_type&)
+ n = m.erase(const_lvalue); // erase(const key_type&)
assert(n == 1);
- assert((m == M{{4,4}}));
+ assert((m == M{{4, 4}}));
}
{
using M = std::flat_map<int, int, std::less<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
- M m = {{1,1}, {2,2}, {3,3}, {4,4}};
+ M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
auto n = m.erase(3); // erase(K&&) [with K=int]
assert(n == 1);
- assert((m == M{{1,1}, {2,2}, {4,4}}));
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}}));
M::key_type lvalue = 2;
- n = m.erase(lvalue); // erase(K&&) [with K=int&]
+ n = m.erase(lvalue); // erase(K&&) [with K=int&]
assert(n == 1);
- assert((m == M{{1,1}, {4,4}}));
+ assert((m == M{{1, 1}, {4, 4}}));
const M::key_type const_lvalue = 1;
- n = m.erase(const_lvalue); // erase(const key_type&)
+ n = m.erase(const_lvalue); // erase(const key_type&)
assert(n == 1);
- assert((m == M{{4,4}}));
+ assert((m == M{{4, 4}}));
}
{
// P2077's HeterogeneousKey example
- using M = std::flat_map<int, int, std::less<>>;
- M m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
- auto h1 = HeterogeneousKey<int, M::iterator>(8, m.begin());
+ using M = std::flat_map<int, int, std::less<>>;
+ M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
+ auto h1 = HeterogeneousKey<int, M::iterator>(8, m.begin());
std::same_as<M::size_type> auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match
assert(n == 1);
- assert((m == M{{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}}));
std::same_as<M::iterator> auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out
assert(it == m.begin());
- assert((m == M{{2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ assert((m == M{{2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}}));
}
{
- using M = std::flat_map<int, int, std::less<>>;
- M m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
- auto h1 = HeterogeneousKey<int, M::const_iterator>(8, m.begin());
+ using M = std::flat_map<int, int, std::less<>>;
+ M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
+ auto h1 = HeterogeneousKey<int, M::const_iterator>(8, m.begin());
std::same_as<M::size_type> auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match
assert(n == 1);
- assert((m == M{{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}}));
std::same_as<M::iterator> auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out
assert(it == m.begin());
- assert((m == M{{2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}}));
+ assert((m == M{{2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}}));
}
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
index 4f3f4a832d5575..32a9c2d2f74169 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
@@ -23,11 +23,10 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, char>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
assert(m.find(0) == m.end());
@@ -41,6 +40,9 @@ int main(int, char**)
assert(std::as_const(m).find(8) == m.begin() + 4);
assert(std::as_const(m).find(9) == m.end());
}
+// std::string is not a sequence container
+#if 0
+
{
using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::string>;
M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
@@ -57,17 +59,18 @@ int main(int, char**)
assert(std::as_const(m).find(8) == m.begin());
assert(std::as_const(m).find(9) == m.end());
}
+#endif
{
using M = std::flat_map<bool, bool>;
- M m = {{true,false}, {false,true}};
+ M m = {{true, false}, {false, true}};
ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
assert(m.find(true) == m.begin() + 1);
assert(m.find(false) == m.begin());
- m = {{true,true}};
+ m = {{true, true}};
assert(m.find(true) == m.begin());
assert(m.find(false) == m.end());
- m = {{false,false}};
+ m = {{false, false}};
assert(std::as_const(m).find(true) == m.end());
assert(std::as_const(m).find(false) == m.begin());
m.clear();
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
index 860959ed4f01be..d190e6a3adc9cf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
@@ -18,28 +18,13 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.find(StartsWith('b'))), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).find(StartsWith('b'))), M::const_iterator);
assert(m.find("beta") == m.begin() + 1);
@@ -49,7 +34,7 @@ int main(int, char**)
assert(m.find(StartsWith('d')) == m.end());
auto it = m.find(StartsWith('e'));
assert(m.begin() + 2 <= it && it <= m.begin() + 3); // either is acceptable
- LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
+ LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
assert(m.find(StartsWith('z')) == m.end());
}
return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
new file mode 100644
index 00000000000000..f2c0a6dd4bb1a9
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FLAT_MAP_HELPERS_H
+#define SUPPORT_FLAT_MAP_HELPERS_H
+
+#include <cassert>
+#include <string>
+
+struct StartsWith {
+ explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {}
+ StartsWith(const StartsWith&) = delete;
+ void operator=(const StartsWith&) = delete;
+ struct Less {
+ using is_transparent = void;
+ bool operator()(const std::string& a, const std::string& b) const { return a < b; }
+ bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
+ bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
+ bool operator()(const StartsWith&, const StartsWith&) const {
+ assert(false); // should not be called
+ return false;
+ }
+ };
+
+private:
+ std::string lower_;
+ std::string upper_;
+};
+
+#endif // SUPPORT_FLAT_MAP_HELPERS_H
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
index 20e941cb64337a..2699a3a3c87e39 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
@@ -27,11 +27,10 @@
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
- M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
ASSERT_SAME_TYPE(decltype(m.begin()), M::iterator);
ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
ASSERT_SAME_TYPE(decltype(m.end()), M::iterator);
@@ -39,22 +38,24 @@ int main(int, char**)
assert(m.size() == 4);
assert(std::distance(m.begin(), m.end()) == 4);
assert(std::distance(m.cbegin(), m.cend()) == 4);
- M::iterator i; // default-construct
- i = m.begin(); // move-assignment
- M::const_iterator k = i; // converting constructor
- assert(i == k); // comparison
- for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
- assert(i->first == j); // operator->
+ M::iterator i; // default-construct
+ i = m.begin(); // move-assignment
+ M::const_iterator k = i; // converting constructor
+ assert(i == k); // comparison
+ for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
+ assert(i->first == j); // operator->
assert(i->second == 'a' + j - 1);
}
assert(i == m.end());
for (int j = 4; j >= 1; --j) {
- --i; // pre-decrement
+ --i; // pre-decrement
assert((*i).first == j);
assert((*i).second == 'a' + j - 1);
}
assert(i == m.begin());
}
+// std::string is not a sequence container
+#if 0
{
using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
@@ -79,6 +80,7 @@ int main(int, char**)
}
assert(i == m.begin());
}
+#endif
{
// N3644 testing
using C = std::flat_map<int, char>;
@@ -89,8 +91,8 @@ int main(int, char**)
assert(ii1 == ii4);
assert(!(ii1 != ii2));
- assert( (ii1 == cii));
- assert( (cii == ii1));
+ assert((ii1 == cii));
+ assert((cii == ii1));
assert(!(ii1 != cii));
assert(!(cii != ii1));
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
index 22ebc599b3f245..5addd191bcf7b5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
@@ -22,8 +22,9 @@
#include "MinSequenceContainer.h"
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
+// V is not a container as <=> is required
+#if 0
{
using V = MinSequenceContainer<int, random_access_iterator<int*>, random_access_iterator<const int*>>;
using M = std::flat_map<int, int, std::less<int>, V, V>;
@@ -46,14 +47,15 @@ int main(int, char**)
static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
}
+#endif
{
- using V = MinSequenceContainer<int, int*, const int*>;
- using M = std::flat_map<int, int, std::less<int>, V, V>;
- using VI = V::iterator;
+ using V = MinSequenceContainer<int, int*, const int*>;
+ using M = std::flat_map<int, int, std::less<int>, V, V>;
+ using VI = V::iterator;
using VCI = V::const_iterator;
- using I = M::iterator;
- using CI = M::const_iterator;
- using RI = M::reverse_iterator;
+ using I = M::iterator;
+ using CI = M::const_iterator;
+ using RI = M::reverse_iterator;
using CRI = M::const_reverse_iterator;
static_assert(std::three_way_comparable<VI>); // And when VI does support <=>...
static_assert(std::three_way_comparable<VCI>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
index a391d099f3addf..a5dca0e9f80423 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
@@ -18,28 +18,13 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.lower_bound(StartsWith('b'))), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(StartsWith('b'))), M::const_iterator);
assert(m.lower_bound("beta") == m.begin() + 1);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
index 586933c6403607..123dac1cc18f42 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
@@ -20,6 +20,7 @@
#include <flat_map>
#include <functional>
#include <limits>
+#include <vector>
#include "test_comparisons.h"
#include "test_container_comparisons.h"
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
index 3afdb56d48e28d..0bfff0c70b2739 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
@@ -25,13 +25,15 @@
#include <functional>
#include <string>
+#include <iterator>
+
#include "test_macros.h"
+#include <iostream>
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
- M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
ASSERT_SAME_TYPE(decltype(m.rbegin()), M::reverse_iterator);
ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator);
ASSERT_SAME_TYPE(decltype(m.rend()), M::reverse_iterator);
@@ -39,24 +41,26 @@ int main(int, char**)
assert(m.size() == 4);
assert(std::distance(m.rbegin(), m.rend()) == 4);
assert(std::distance(m.crbegin(), m.crend()) == 4);
- M::reverse_iterator i; // default-construct
+ M::reverse_iterator i; // default-construct
ASSERT_SAME_TYPE(decltype(i->first), const int&);
ASSERT_SAME_TYPE(decltype(i->second), char&);
- i = m.rbegin(); // move-assignment
- M::const_reverse_iterator k = i; // converting constructor
- assert(i == k); // comparison
- for (int j = 4; j >= 1; --j, ++i) { // pre-increment
- assert(i->first == j); // operator->
+ i = m.rbegin(); // move-assignment
+ M::const_reverse_iterator k = i; // converting constructor
+ assert(i == k); // comparison
+ for (int j = 4; j >= 1; --j, ++i) { // pre-increment
+ assert(i->first == j); // operator->
assert(i->second == 'a' + j - 1);
}
assert(i == m.rend());
for (int j = 1; j <= 4; ++j) {
- --i; // pre-decrement
+ --i; // pre-decrement
assert((*i).first == j);
assert((*i).second == 'a' + j - 1);
}
assert(i == m.rbegin());
}
+// std::string is not a sequence container
+#if 0
{
using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
@@ -83,6 +87,7 @@ int main(int, char**)
}
assert(i == m.rbegin());
}
+#endif
{
// N3644 testing
using C = std::flat_map<int, char>;
@@ -93,8 +98,8 @@ int main(int, char**)
assert(ii1 == ii4);
assert(!(ii1 != ii2));
- assert( (ii1 == cii));
- assert( (cii == ii1));
+ assert((ii1 == cii));
+ assert((cii == ii1));
assert(!(ii1 != cii));
assert(!(cii != ii1));
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
index 745a250c068fa1..6c06eea59c9658 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
@@ -18,28 +18,13 @@
#include <string>
#include <utility>
+#include "helpers.h"
#include "test_macros.h"
-struct StartsWith {
- explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch+1) {}
- StartsWith(const StartsWith&) = delete;
- void operator=(const StartsWith&) = delete;
- struct Less {
- using is_transparent = void;
- bool operator()(const std::string& a, const std::string& b) const { return a < b; }
- bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; }
- bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; }
- };
-private:
- std::string lower_;
- std::string upper_;
-};
-
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = { {"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5} };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
ASSERT_SAME_TYPE(decltype(m.upper_bound(StartsWith('b'))), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(StartsWith('b'))), M::const_iterator);
assert(m.upper_bound("beta") == m.begin() + 2);
diff --git a/libcxx/test/support/MinSequenceContainer.h b/libcxx/test/support/MinSequenceContainer.h
new file mode 100644
index 00000000000000..9f6cadbef1a8e5
--- /dev/null
+++ b/libcxx/test/support/MinSequenceContainer.h
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_MIN_SEQUENCE_CONTAINER_H
+#define SUPPORT_MIN_SEQUENCE_CONTAINER_H
+
+#include <initializer_list>
+#include <vector>
+
+#include "test_iterators.h"
+
+template<class T, class Iterator = random_access_iterator<T*>,
+ class ConstIterator = random_access_iterator<const T*>>
+struct MinSequenceContainer {
+ using value_type = T;
+ using difference_type = short;
+ using size_type = unsigned short;
+ using iterator = Iterator;
+ using const_iterator = ConstIterator;
+
+ explicit MinSequenceContainer() = default;
+ template<class It> explicit MinSequenceContainer(It first, It last) : data_(first, last) {}
+ MinSequenceContainer(std::initializer_list<T> il) : data_(il) {}
+ iterator begin() { return iterator(data_.data()); }
+ const_iterator begin() const { return const_iterator(data_.data()); }
+ const_iterator cbegin() const { return const_iterator(data_.data()); }
+ iterator end() { return begin() + size(); }
+ const_iterator end() const { return begin() + size(); }
+ size_type size() const { return data_.size(); }
+ bool empty() const { return data_.empty(); }
+
+ void clear() { data_.clear(); }
+
+ template<class It>
+ iterator insert(const_iterator p, It first, It last) {
+ auto it = data_.insert(
+ p - cbegin() + data_.begin(),
+ first, last
+ );
+ return it - data_.begin() + begin();
+ }
+
+ iterator insert(const_iterator p, int value) {
+ auto it = data_.insert(
+ p - cbegin() + data_.begin(),
+ value
+ );
+ return it - data_.begin() + begin();
+ }
+
+ iterator erase(const_iterator first, const_iterator last) {
+ auto it = data_.erase(first - cbegin() + data_.begin(), last - cbegin() + data_.begin());
+ return it - data_.begin() + begin();
+ }
+
+private:
+ std::vector<T> data_;
+};
+
+namespace MinSequenceContainer_detail {
+
+// MinSequenceContainer is non-allocator-aware, because flat_set supports
+// such (non-STL) container types, and we want to make sure they are supported.
+template<class T>
+concept HasAllocatorType = requires { typename T::allocator_type; };
+static_assert(!HasAllocatorType<MinSequenceContainer<int>>);
+
+// MinSequenceContainer by itself doesn't support .emplace(), because we want
+// to at least somewhat support (non-STL) container types with nothing but .insert().
+template<class T>
+concept HasEmplace = requires (T& t) { t.emplace(42); };
+static_assert(!HasEmplace<MinSequenceContainer<int>>);
+
+} // MinSequenceContainer_detail
+
+#endif // SUPPORT_MIN_SEQUENCE_CONTAINER_H
>From 6cc6ce2e26c768f61c284fbf0820a209b8db20af Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 21 Aug 2024 10:30:38 +0100
Subject: [PATCH 04/40] clang-format tests
---
.../flat.map/container_stability.pass.cpp | 5 +-
.../flat.map/clear.pass.cpp | 16 +-
.../container.adaptors/flat.map/comp.pass.cpp | 28 ++--
.../flat.map/contains.pass.cpp | 41 +++---
.../flat.map/count.pass.cpp | 13 +-
.../flat.map/empty.pass.cpp | 3 +-
.../flat.map/empty.verify.cpp | 3 +-
.../flat.map/equal_range.pass.cpp | 70 ++++-----
.../flat.map/erase_key.pass.cpp | 47 +++---
.../flat.map/flat.map.cons/alloc.pass.cpp | 12 +-
.../assign_initializer_list.pass.cpp | 32 ++--
.../flat.map/flat.map.cons/compare.pass.cpp | 17 +--
.../flat.map.cons/containers.pass.cpp | 77 +++++-----
.../flat.map.cons/containers_compare.pass.cpp | 77 +++++-----
.../flat.map/flat.map.cons/copy.pass.cpp | 25 ++--
.../flat.map.cons/copy_alloc.pass.cpp | 19 ++-
.../flat.map.cons/copy_assign.pass.cpp | 41 +++---
.../flat.map/flat.map.cons/deduct.pass.cpp | 137 ++++++++++--------
.../flat.map/flat.map.cons/deduct.verify.cpp | 40 ++---
.../flat.map/flat.map.cons/default.pass.cpp | 3 +-
.../flat.map.cons/default_noexcept.pass.cpp | 7 +-
.../flat.map.cons/dtor_noexcept.pass.cpp | 3 +-
.../flat.map.cons/initializer_list.pass.cpp | 38 ++---
.../initializer_list_compare.pass.cpp | 41 +++---
.../flat.map/flat.map.cons/iter_iter.pass.cpp | 29 ++--
.../flat.map.cons/iter_iter_comp.pass.cpp | 29 ++--
.../iter_iter_stability.pass.cpp | 5 +-
.../flat.map/flat.map.cons/move.pass.cpp | 27 ++--
.../flat.map.cons/move_alloc.pass.cpp | 35 +++--
.../flat.map.cons/move_assign.pass.cpp | 62 ++++----
.../flat.map.cons/move_assign_clears.pass.cpp | 67 +++++----
.../move_assign_noexcept.pass.cpp | 40 +++--
.../flat.map.cons/move_exceptions.pass.cpp | 11 +-
.../flat.map.cons/move_noexcept.pass.cpp | 18 ++-
.../flat.map.cons/sorted_container.pass.cpp | 63 ++++----
.../sorted_iter_iter_comp.pass.cpp | 58 ++++----
.../flat.map.erasure/erase_if.pass.cpp | 76 +++++-----
.../erase_if_exceptions.pass.cpp | 72 +++++----
.../flat.map/incomplete_type.pass.cpp | 2 +-
.../flat.map/insert_range.pass.cpp | 53 ++++---
.../flat.map/insert_range_stability.pass.cpp | 5 +-
.../flat.map/insert_transparent.pass.cpp | 57 ++++----
...rator_concept_conformance.compile.pass.cpp | 72 ++++-----
.../flat.map/lower_bound.pass.cpp | 20 ++-
.../flat.map/max_size.pass.cpp | 13 +-
.../flat.map/op_compare.pass.cpp | 46 +++---
.../flat.map/types.pass.cpp | 3 +-
.../flat.map/upper_bound.pass.cpp | 20 ++-
48 files changed, 863 insertions(+), 815 deletions(-)
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
index a76d78ac816ea5..0d90c3250061ff 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/container_stability.pass.cpp
@@ -30,12 +30,11 @@ struct Mod256 {
bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
};
-int main(int, char**)
-{
+int main(int, char**) {
std::mt19937 randomness;
std::vector<uint16_t> values;
std::vector<std::pair<uint16_t, uint16_t>> pairs;
- for (int i=0; i < 200; ++i) {
+ for (int i = 0; i < 200; ++i) {
uint16_t r = randomness();
values.push_back(r);
pairs.emplace_back(r, r);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
index ec0172347641d8..0ad01d93c94386 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
@@ -23,11 +23,10 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, int>;
- M m = {{1,2}, {2,1}, {3,3}, {4,1}, {5,0}};
+ M m = {{1, 2}, {2, 1}, {3, 3}, {4, 1}, {5, 0}};
assert(m.size() == 5);
ASSERT_NOEXCEPT(m.clear());
ASSERT_SAME_TYPE(decltype(m.clear()), void);
@@ -35,8 +34,13 @@ int main(int, char**)
assert(m.size() == 0);
}
{
- using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
- M m = {{1,2}, {2,1}, {3,3}, {4,1}, {5,0}};
+ using M =
+ std::flat_map<int,
+ int,
+ std::greater<int>,
+ std::deque<int, min_allocator<int>>,
+ std::vector<int, min_allocator<int>>>;
+ M m = {{1, 2}, {2, 1}, {3, 3}, {4, 1}, {5, 0}};
assert(m.size() == 5);
ASSERT_NOEXCEPT(m.clear());
ASSERT_SAME_TYPE(decltype(m.clear()), void);
@@ -45,7 +49,7 @@ int main(int, char**)
}
{
using M = std::flat_map<bool, bool>;
- M m = {{true,false}, {false,true}};
+ M m = {{true, false}, {false, true}};
assert(m.size() == 2);
ASSERT_NOEXCEPT(m.clear());
ASSERT_SAME_TYPE(decltype(m.clear()), void);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
index c1cf9307ce498a..d86224952dee45 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
@@ -23,9 +23,9 @@
int main(int, char**) {
{
- using M = std::flat_map<int, char>;
+ using M = std::flat_map<int, char>;
using Comp = std::less<int>; // the default
- M m = {};
+ M m = {};
ASSERT_SAME_TYPE(M::key_compare, Comp);
static_assert(!std::is_same_v<M::value_compare, Comp>);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
@@ -40,8 +40,8 @@ int main(int, char**) {
}
{
using Comp = std::function<bool(int, int)>;
- using M = std::flat_map<int, int, Comp>;
- Comp comp = std::greater<int>();
+ using M = std::flat_map<int, int, Comp>;
+ Comp comp = std::greater<int>();
M m({}, comp);
ASSERT_SAME_TYPE(M::key_compare, Comp);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
@@ -50,7 +50,7 @@ int main(int, char**) {
assert(!kc(1, 2));
assert(kc(2, 1));
auto vc = m.value_comp();
- auto a = std::make_pair(1, 2);
+ auto a = std::make_pair(1, 2);
ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
static_assert(!noexcept(vc(a, a)));
assert(!vc({1, 2}, {2, 1}));
@@ -58,8 +58,8 @@ int main(int, char**) {
}
{
using Comp = std::less<>;
- using M = std::flat_map<int, int, Comp>;
- M m = {};
+ using M = std::flat_map<int, int, Comp>;
+ M m = {};
ASSERT_SAME_TYPE(M::key_compare, Comp);
ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp);
ASSERT_SAME_TYPE(decltype(m.value_comp()), M::value_compare);
@@ -67,26 +67,26 @@ int main(int, char**) {
assert(kc(1, 2));
assert(!kc(2, 1));
auto vc = m.value_comp();
- auto a = std::make_pair(1, 2);
+ auto a = std::make_pair(1, 2);
ASSERT_SAME_TYPE(decltype(vc(a, a)), bool);
assert(vc({1, 2}, {2, 1}));
assert(!vc({2, 1}, {1, 2}));
}
{
using Comp = std::function<bool(const std::vector<int>&, const std::vector<int>&)>;
- using M = std::flat_map<std::vector<int>, int, Comp>;
- Comp comp = [i=1](const auto& x, const auto& y) { return x[i] < y[i]; };
+ using M = std::flat_map<std::vector<int>, int, Comp>;
+ Comp comp = [i = 1](const auto& x, const auto& y) { return x[i] < y[i]; };
M m({}, comp);
auto vc = m.value_comp();
static_assert(sizeof(vc) >= sizeof(Comp));
comp = nullptr;
- m = M({}, nullptr);
+ m = M({}, nullptr);
assert(m.key_comp() == nullptr);
// At this point, m.key_comp() is disengaged.
// But the std::function captured by copy inside `vc` remains valid.
- auto a = std::make_pair(std::vector<int>{2,1,4}, 42);
- auto b = std::make_pair(std::vector<int>{1,2,3}, 42);
- auto c = std::make_pair(std::vector<int>{0,3,2}, 42);
+ auto a = std::make_pair(std::vector<int>{2, 1, 4}, 42);
+ auto b = std::make_pair(std::vector<int>{1, 2, 3}, 42);
+ auto c = std::make_pair(std::vector<int>{0, 3, 2}, 42);
assert(vc(a, b));
assert(vc(b, c));
assert(!vc(b, a));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
index 5f1def4304cf11..930ee4329d1d9c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
@@ -21,51 +21,50 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, const char*>;
- M m = {{1,""}, {2,""}, {4,""}, {5,""}, {8,""}};
+ M m = {{1, ""}, {2, ""}, {4, ""}, {5, ""}, {8, ""}};
assert(!m.contains(0));
- assert( m.contains(1));
- assert( m.contains(2));
+ assert(m.contains(1));
+ assert(m.contains(2));
assert(!m.contains(3));
- assert( m.contains(4));
- assert( m.contains(5));
+ assert(m.contains(4));
+ assert(m.contains(5));
assert(!m.contains(6));
assert(!m.contains(7));
- assert( std::as_const(m).contains(8));
+ assert(std::as_const(m).contains(8));
assert(!std::as_const(m).contains(9));
m.clear();
assert(!m.contains(1));
}
{
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
- M m = {{1,0}, {2,0}, {4,0}, {5,0}, {8,0}};
+ M m = {{1, 0}, {2, 0}, {4, 0}, {5, 0}, {8, 0}};
assert(!m.contains(0));
- assert( m.contains(1));
- assert( m.contains(2));
+ assert(m.contains(1));
+ assert(m.contains(2));
assert(!m.contains(3));
- assert( m.contains(4));
- assert( m.contains(5));
+ assert(m.contains(4));
+ assert(m.contains(5));
assert(!m.contains(6));
assert(!m.contains(7));
- assert( std::as_const(m).contains(8));
+ assert(std::as_const(m).contains(8));
assert(!std::as_const(m).contains(9));
m.clear();
assert(!m.contains(1));
}
{
using M = std::flat_map<bool, int>;
- M m = {{true,1}, {false,2}};
- assert( m.contains(true));
- assert( m.contains(false));
- m = {{true,3}};
- assert( m.contains(true));
+ M m = {{true, 1}, {false, 2}};
+ assert(m.contains(true));
+ assert(m.contains(false));
+ m = {{true, 3}};
+ assert(m.contains(true));
assert(!m.contains(false));
- m = {{false,4}};
+ m = {{false, 4}};
assert(!std::as_const(m).contains(true));
- assert( std::as_const(m).contains(false));
+ assert(std::as_const(m).contains(false));
m.clear();
assert(!m.contains(true));
assert(!m.contains(false));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
index bca4251bdb36bb..a0858c6adc6803 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
@@ -21,11 +21,10 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, const char*>;
- M m = {{1,""}, {2,""}, {4,""}, {5,""}, {8,""}};
+ M m = {{1, ""}, {2, ""}, {4, ""}, {5, ""}, {8, ""}};
ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
assert(m.count(0) == 0);
assert(m.count(1) == 1);
@@ -40,7 +39,7 @@ int main(int, char**)
}
{
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
- M m = {{1,0}, {2,0}, {4,0}, {5,0}, {8,0}};
+ M m = {{1, 0}, {2, 0}, {4, 0}, {5, 0}, {8, 0}};
ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
assert(m.count(0) == 0);
assert(m.count(1) == 1);
@@ -55,14 +54,14 @@ int main(int, char**)
}
{
using M = std::flat_map<bool, int>;
- M m = {{true,1}, {false,2}};
+ M m = {{true, 1}, {false, 2}};
ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
assert(m.count(true) == 1);
assert(m.count(false) == 1);
- m = {{true,3}};
+ m = {{true, 3}};
assert(m.count(true) == 1);
assert(m.count(false) == 0);
- m = {{false,4}};
+ m = {{false, 4}};
assert(std::as_const(m).count(true) == 0);
assert(std::as_const(m).count(false) == 1);
m.clear();
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
index 000b36daa9988e..72ac225e25a062 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
@@ -21,8 +21,7 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
typedef std::flat_map<int, int> M;
M m;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
index 8d98abf10ad645..cc8016182dcb66 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
@@ -16,8 +16,7 @@
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
std::flat_map<int, int> c;
c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
index 6d1c3fd4d38d72..1c95006bddeec6 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
@@ -22,59 +22,63 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, char>;
- using R = std::pair<M::iterator, M::iterator>;
+ using M = std::flat_map<int, char>;
+ using R = std::pair<M::iterator, M::iterator>;
using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
auto begin = m.begin();
assert(m.equal_range(0) == std::pair(begin, begin));
- assert(m.equal_range(1) == std::pair(begin, begin+1));
- assert(m.equal_range(2) == std::pair(begin+1, begin+2));
- assert(m.equal_range(3) == std::pair(begin+2, begin+2));
- assert(m.equal_range(4) == std::pair(begin+2, begin+3));
- assert(m.equal_range(5) == std::pair(begin+3, begin+4));
- assert(m.equal_range(6) == std::pair(begin+4, begin+4));
- assert(m.equal_range(7) == std::pair(begin+4, begin+4));
- assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin()+4, m.cbegin()+5));
- assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin()+5, m.cbegin()+5));
+ assert(m.equal_range(1) == std::pair(begin, begin + 1));
+ assert(m.equal_range(2) == std::pair(begin + 1, begin + 2));
+ assert(m.equal_range(3) == std::pair(begin + 2, begin + 2));
+ assert(m.equal_range(4) == std::pair(begin + 2, begin + 3));
+ assert(m.equal_range(5) == std::pair(begin + 3, begin + 4));
+ assert(m.equal_range(6) == std::pair(begin + 4, begin + 4));
+ assert(m.equal_range(7) == std::pair(begin + 4, begin + 4));
+ assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin() + 4, m.cbegin() + 5));
+ assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin() + 5, m.cbegin() + 5));
}
{
- using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
- using R = std::pair<M::iterator, M::iterator>;
+ using M =
+ std::flat_map<int,
+ char,
+ std::greater<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<char, min_allocator<char>>>;
+ using R = std::pair<M::iterator, M::iterator>;
using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
auto begin = m.begin();
- assert(m.equal_range(0) == std::pair(begin+5, begin+5));
- assert(m.equal_range(1) == std::pair(begin+4, begin+5));
- assert(m.equal_range(2) == std::pair(begin+3, begin+4));
- assert(m.equal_range(3) == std::pair(begin+3, begin+3));
- assert(m.equal_range(4) == std::pair(begin+2, begin+3));
- assert(m.equal_range(5) == std::pair(begin+1, begin+2));
- assert(m.equal_range(6) == std::pair(begin+1, begin+1));
- assert(m.equal_range(7) == std::pair(begin+1, begin+1));
- assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin()+1));
+ assert(m.equal_range(0) == std::pair(begin + 5, begin + 5));
+ assert(m.equal_range(1) == std::pair(begin + 4, begin + 5));
+ assert(m.equal_range(2) == std::pair(begin + 3, begin + 4));
+ assert(m.equal_range(3) == std::pair(begin + 3, begin + 3));
+ assert(m.equal_range(4) == std::pair(begin + 2, begin + 3));
+ assert(m.equal_range(5) == std::pair(begin + 1, begin + 2));
+ assert(m.equal_range(6) == std::pair(begin + 1, begin + 1));
+ assert(m.equal_range(7) == std::pair(begin + 1, begin + 1));
+ assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin() + 1));
assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin()));
}
{
- using M = std::flat_map<bool, bool>;
- using R = std::pair<M::iterator, M::iterator>;
+ using M = std::flat_map<bool, bool>;
+ using R = std::pair<M::iterator, M::iterator>;
using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{true,false}, {false,true}};
+ M m = {{true, false}, {false, true}};
ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
- assert(m.equal_range(true) == std::pair(m.begin()+1, m.end()));
- assert(m.equal_range(false) == std::pair(m.begin(), m.begin()+1));
- m = {{true,true}};
+ assert(m.equal_range(true) == std::pair(m.begin() + 1, m.end()));
+ assert(m.equal_range(false) == std::pair(m.begin(), m.begin() + 1));
+ m = {{true, true}};
assert(m.equal_range(true) == std::pair(m.begin(), m.end()));
assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
- m = {{false,false}};
+ m = {{false, false}};
assert(std::as_const(m).equal_range(true) == std::pair(m.cend(), m.cend()));
assert(std::as_const(m).equal_range(false) == std::pair(m.cbegin(), m.cend()));
m.clear();
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
index 8b76882138921a..50dd566b0b7f5e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
@@ -22,10 +22,9 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, char>;
+ using M = std::flat_map<int, char>;
auto make = [](std::initializer_list<int> il) {
M m;
for (int i : il) {
@@ -33,32 +32,32 @@ int main(int, char**)
}
return m;
};
- M m = make({1,2,3,4,5,6,7,8});
+ M m = make({1, 2, 3, 4, 5, 6, 7, 8});
ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
auto n = m.erase(9);
assert(n == 0);
- assert(m == make({1,2,3,4,5,6,7,8}));
+ assert(m == make({1, 2, 3, 4, 5, 6, 7, 8}));
n = m.erase(4);
assert(n == 1);
- assert(m == make({1,2,3,5,6,7,8}));
+ assert(m == make({1, 2, 3, 5, 6, 7, 8}));
n = m.erase(1);
assert(n == 1);
- assert(m == make({2,3,5,6,7,8}));
+ assert(m == make({2, 3, 5, 6, 7, 8}));
n = m.erase(8);
assert(n == 1);
- assert(m == make({2,3,5,6,7}));
+ assert(m == make({2, 3, 5, 6, 7}));
n = m.erase(3);
assert(n == 1);
- assert(m == make({2,5,6,7}));
+ assert(m == make({2, 5, 6, 7}));
n = m.erase(4);
assert(n == 0);
- assert(m == make({2,5,6,7}));
+ assert(m == make({2, 5, 6, 7}));
n = m.erase(6);
assert(n == 1);
- assert(m == make({2,5,7}));
+ assert(m == make({2, 5, 7}));
n = m.erase(7);
assert(n == 1);
- assert(m == make({2,5}));
+ assert(m == make({2, 5}));
n = m.erase(2);
assert(n == 1);
assert(m == make({5}));
@@ -67,7 +66,7 @@ int main(int, char**)
assert(m.empty());
}
{
- using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
+ using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
auto make = [](std::initializer_list<int> il) {
M m;
for (int i : il) {
@@ -75,34 +74,34 @@ int main(int, char**)
}
return m;
};
- M::key_container_type container = {5,6,7,8};
- container.insert(container.begin(), {1,2,3,4});
- M m = M(std::move(container), {1,2,3,4,5,6,7,8});
+ M::key_container_type container = {5, 6, 7, 8};
+ container.insert(container.begin(), {1, 2, 3, 4});
+ M m = M(std::move(container), {1, 2, 3, 4, 5, 6, 7, 8});
ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
auto n = m.erase(9);
assert(n == 0);
- assert(m == make({1,2,3,4,5,6,7,8}));
+ assert(m == make({1, 2, 3, 4, 5, 6, 7, 8}));
n = m.erase(4);
assert(n == 1);
- assert(m == make({1,2,3,5,6,7,8}));
+ assert(m == make({1, 2, 3, 5, 6, 7, 8}));
n = m.erase(1);
assert(n == 1);
- assert(m == make({2,3,5,6,7,8}));
+ assert(m == make({2, 3, 5, 6, 7, 8}));
n = m.erase(8);
assert(n == 1);
- assert(m == make({2,3,5,6,7}));
+ assert(m == make({2, 3, 5, 6, 7}));
n = m.erase(3);
assert(n == 1);
- assert(m == make({2,5,6,7}));
+ assert(m == make({2, 5, 6, 7}));
n = m.erase(4);
assert(n == 0);
- assert(m == make({2,5,6,7}));
+ assert(m == make({2, 5, 6, 7}));
n = m.erase(6);
assert(n == 1);
- assert(m == make({2,5,7}));
+ assert(m == make({2, 5, 7}));
n = m.erase(7);
assert(n == 1);
- assert(m == make({2,5}));
+ assert(m == make({2, 5}));
n = m.erase(2);
assert(n == 1);
assert(m == make({5}));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
index cbfefa8a66b494..4aa55c1a0fbc43 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -22,11 +22,15 @@
#include "test_macros.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using A = test_allocator<short>;
- using M = std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>;
+ using M =
+ std::flat_map<int,
+ long,
+ std::less<int>,
+ std::vector<int, test_allocator<int>>,
+ std::vector<long, test_allocator<long>>>;
M m(A(0, 5));
assert(m.empty());
assert(m.begin() == m.end());
@@ -37,7 +41,7 @@ int main(int, char**)
using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::polymorphic_allocator<int> pa = &mr;
- auto m1 = M(pa);
+ auto m1 = M(pa);
assert(m1.empty());
assert(m1.keys().get_allocator() == pa);
assert(m1.values().get_allocator() == pa);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
index 91e969b8e10001..1d0c8657f78219 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
@@ -27,37 +27,43 @@
int main(int, char**) {
{
using C = std::flat_map<int, int>;
- C m = {{8,8}, {10,10}};
+ C m = {{8, 8}, {10, 10}};
assert(m.size() == 2);
- m = {{3,0}, {1,0}, {2,0}, {2,1}, {3,1}, {4,0}, {3,2}, {5,0}, {6,0}, {5,1}};
- std::pair<int, int> expected[] = {{1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}};
+ m = {{3, 0}, {1, 0}, {2, 0}, {2, 1}, {3, 1}, {4, 0}, {3, 2}, {5, 0}, {6, 0}, {5, 1}};
+ std::pair<int, int> expected[] = {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}};
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
}
{
- using C = std::flat_map<int, int, std::less<>, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
- C m = {{1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}};
+ using C = std::
+ flat_map<int, int, std::less<>, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
+ C m = {{1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}, {6, 1}, {7, 1}, {8, 1}, {9, 1}, {10, 1}};
assert(m.size() == 10);
- m = {{1,1}, {3,2}, {4,3}, {5,4}, {6,5}, {5,6}, {2,7}};
- std::pair<int, int> expected[] = {{1,1}, {2,7}, {3,2}, {4,3}, {5,4}, {6,5}};
+ m = {{1, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 5}, {5, 6}, {2, 7}};
+ std::pair<int, int> expected[] = {{1, 1}, {2, 7}, {3, 2}, {4, 3}, {5, 4}, {6, 5}};
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
}
{
- using C = std::flat_map<double, int, std::less<>, std::deque<double, min_allocator<double>>, std::vector<int, min_allocator<int>>>;
+ using C =
+ std::flat_map<double,
+ int,
+ std::less<>,
+ std::deque<double, min_allocator<double>>,
+ std::vector<int, min_allocator<int>>>;
C m = {};
assert(m.size() == 0);
- m = {{3,0}, {1,0}, {2,0}, {2,1}, {3,1}, {4,0}, {3,2}, {5,0}, {6,0}, {5,1}};
- std::pair<double, int> expected[] = {{1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}};
+ m = {{3, 0}, {1, 0}, {2, 0}, {2, 1}, {3, 1}, {4, 0}, {3, 2}, {5, 0}, {6, 0}, {5, 1}};
+ std::pair<double, int> expected[] = {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}};
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
}
{
using C = std::flat_map<double, double, std::less<>, std::deque<double>, std::deque<double>>;
- C m = {{10,1}, {8,1}};
+ C m = {{10, 1}, {8, 1}};
assert(m.size() == 2);
- m = {{3,2}};
- std::pair<double, double> expected[] = {{3,2}};
+ m = {{3, 2}};
+ std::pair<double, double> expected[] = {{3, 2}};
assert(std::ranges::equal(m, expected));
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
index 445095742bbae5..9cce469782b07f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
@@ -25,11 +25,10 @@
#include "../../../test_compare.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = test_less<int>;
- auto m = std::flat_map<int, char*, C>(C(3));
+ auto m = std::flat_map<int, char*, C>(C(3));
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(3));
@@ -44,10 +43,10 @@ int main(int, char**)
static_assert(!std::is_convertible_v<std::less<int>, std::flat_map<int, char*>>);
}
{
- using C = test_less<int>;
+ using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- auto m = std::flat_map<int, short, C, std::vector<int, A1>, std::vector<short, A2>>(C(4), A1(5));
+ auto m = std::flat_map<int, short, C, std::vector<int, A1>, std::vector<short, A2>>(C(4), A1(5));
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(4));
@@ -55,10 +54,10 @@ int main(int, char**)
assert(m.values().get_allocator() == A2(5));
}
{
- using C = test_less<int>;
- using A1 = test_allocator<int>;
- using A2 = test_allocator<short>;
- std::flat_map<int, short, C, std::deque<int, A1>, std::deque<short, A2>> m = { C(4), A1(5) }; // implicit ctor
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ std::flat_map<int, short, C, std::deque<int, A1>, std::deque<short, A2>> m = {C(4), A1(5)}; // implicit ctor
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(4));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
index 0c8d414c9da7c0..70b99b33b8dbca 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
@@ -32,33 +32,32 @@
struct P {
int first;
int second;
- template<class T, class U>
+ template <class T, class U>
bool operator==(const std::pair<T, U>& rhs) const {
return MoveOnly(first) == rhs.first && MoveOnly(second) == rhs.second;
}
};
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, char>;
- std::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::vector<char> vs = {1,2,3,4,5,6,7,8,9};
- auto m = M(ks, vs);
- assert((m.keys() == std::vector<int>{1,2,3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ using M = std::flat_map<int, char>;
+ std::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::vector<char> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ auto m = M(ks, vs);
+ assert((m.keys() == std::vector<int>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
m = M(std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m.keys() == std::vector<int>{1,2,3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ assert((m.keys() == std::vector<int>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
}
{
- P expected[] = {{3,2}, {2,1}, {1,3}};
- using Ks = std::deque<int, min_allocator<int>>;
- using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
- using M = std::flat_map<int, MoveOnly, std::greater<int>, Ks, Vs>;
- Ks ks = {1,3,2};
+ P expected[] = {{3, 2}, {2, 1}, {1, 3}};
+ using Ks = std::deque<int, min_allocator<int>>;
+ using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
+ using M = std::flat_map<int, MoveOnly, std::greater<int>, Ks, Vs>;
+ Ks ks = {1, 3, 2};
Vs vs;
vs.push_back(3);
vs.push_back(2);
@@ -71,36 +70,36 @@ int main(int, char**)
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- auto m = M(std::move(ks), std::move(vs));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ auto m = M(std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.keys().get_allocator() == A(5));
assert(m.values().get_allocator() == A(6));
}
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- auto m = M(ks, vs, A(4)); // replaces the allocators
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ auto m = M(ks, vs, A(4)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.keys().get_allocator() == A(4));
assert(m.values().get_allocator() == A(4));
}
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- M m = { ks, vs, A(4) }; // implicit ctor
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ M m = {ks, vs, A(4)}; // implicit ctor
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.keys().get_allocator() == A(4));
assert(m.values().get_allocator() == A(4));
}
@@ -108,14 +107,14 @@ int main(int, char**)
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
assert(ks.get_allocator().resource() != &mr);
assert(vs.get_allocator().resource() != &mr);
vm.emplace_back(ks, vs);
assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
@@ -123,14 +122,14 @@ int main(int, char**)
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
assert(ks.get_allocator().resource() != &mr);
assert(vs.get_allocator().resource() != &mr);
vm.emplace_back(std::move(ks), std::move(vs));
LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
@@ -223,6 +222,6 @@ int main(int, char**)
assert(vm[0].values().get_allocator().resource() == &mr);
}
}
- #endif
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
index e26f0162802ea5..a48b5d2d67ec5d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
@@ -33,36 +33,35 @@
struct P {
int first;
int second;
- template<class T, class U>
+ template <class T, class U>
bool operator==(const std::pair<T, U>& rhs) const {
return MoveOnly(first) == rhs.first && MoveOnly(second) == rhs.second;
}
};
-int main(int, char**)
-{
+int main(int, char**) {
using C = test_less<int>;
{
- using M = std::flat_map<int, char, C>;
- std::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::vector<char> vs = {1,2,3,4,5,6,7,8,9};
- auto m = M(ks, vs, C(2));
- assert((m.keys() == std::vector<int>{1,2,3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ using M = std::flat_map<int, char, C>;
+ std::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::vector<char> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ auto m = M(ks, vs, C(2));
+ assert((m.keys() == std::vector<int>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
assert(m.key_comp() == C(2));
m = M(std::move(ks), std::move(vs), C(3));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m.keys() == std::vector<int>{1,2,3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1,4,6}));
+ assert((m.keys() == std::vector<int>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
assert(m.key_comp() == C(3));
}
{
- P expected[] = {{1,3}, {2,1}, {3,2}};
- using Ks = std::deque<int, min_allocator<int>>;
- using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
- using M = std::flat_map<int, MoveOnly, C, Ks, Vs>;
- Ks ks = {1,3,2};
+ P expected[] = {{1, 3}, {2, 1}, {3, 2}};
+ using Ks = std::deque<int, min_allocator<int>>;
+ using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
+ using M = std::flat_map<int, MoveOnly, C, Ks, Vs>;
+ Ks ks = {1, 3, 2};
Vs vs;
vs.push_back(3);
vs.push_back(2);
@@ -76,12 +75,12 @@ int main(int, char**)
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- auto m = M(std::move(ks), std::move(vs), C(2));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ auto m = M(std::move(ks), std::move(vs), C(2));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.key_comp() == C(2));
assert(m.keys().get_allocator() == A(5));
assert(m.values().get_allocator() == A(6));
@@ -89,12 +88,12 @@ int main(int, char**)
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- auto m = M(ks, vs, C(2), A(4)); // replaces the allocators
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ auto m = M(ks, vs, C(2), A(4)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.key_comp() == C(2));
assert(m.keys().get_allocator() == A(4));
assert(m.values().get_allocator() == A(4));
@@ -102,12 +101,12 @@ int main(int, char**)
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,1,1,2,2,3,2,3,3}, A(5));
- auto vs = std::deque<int, A>({1,1,1,2,2,3,2,3,3}, A(6));
- M m = { ks, vs, C(2), A(4) }; // implicit ctor
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
+ auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
+ M m = {ks, vs, C(2), A(4)}; // implicit ctor
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.key_comp() == C(2));
assert(m.keys().get_allocator() == A(4));
assert(m.values().get_allocator() == A(4));
@@ -116,14 +115,14 @@ int main(int, char**)
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
assert(ks.get_allocator().resource() != &mr);
assert(vs.get_allocator().resource() != &mr);
vm.emplace_back(ks, vs, C(2));
assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
assert(vm[0].key_comp() == C(2));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
@@ -132,14 +131,14 @@ int main(int, char**)
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,1,1,2,2,3,2,3,3};
- std::pmr::vector<int> vs = {1,1,1,2,2,3,2,3,3};
+ std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
assert(ks.get_allocator().resource() != &mr);
assert(vs.get_allocator().resource() != &mr);
vm.emplace_back(std::move(ks), std::move(vs), C(2));
LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1,1}, {2,2}, {3,3}}));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
assert(vm[0].key_comp() == C(2));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
@@ -241,6 +240,6 @@ int main(int, char**)
assert(vm[0].values().get_allocator().resource() == &mr);
}
}
- #endif
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
index bc1d713abb74d3..a09e10e63b6561 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
@@ -21,15 +21,14 @@
#include "../../../test_compare.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = test_less<int>;
std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
auto mo = M(ks, vs, C(5));
- auto m = mo;
+ auto m = mo;
assert(m.key_comp() == C(5));
assert(m.keys() == ks);
@@ -45,14 +44,14 @@ int main(int, char**)
assert(mo.values().get_allocator() == test_allocator<char>(7));
}
{
- using C = test_less<int>;
+ using C = test_less<int>;
using Ks = std::vector<int, other_allocator<int>>;
using Vs = std::vector<char, other_allocator<char>>;
- auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
- auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
- using M = std::flat_map<int, char, C, Ks, Vs>;
- auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
- auto m = mo;
+ auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
+ auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
+ using M = std::flat_map<int, char, C, Ks, Vs>;
+ auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
+ auto m = mo;
assert(m.key_comp() == C(5));
assert(m.keys() == ks);
@@ -71,18 +70,18 @@ int main(int, char**)
using C = test_less<int>;
std::pmr::monotonic_buffer_resource mr;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- auto mo = M({{1,1}, {2,2}, {3,3}}, C(5), &mr);
- auto m = mo;
+ auto mo = M({{1, 1}, {2, 2}, {3, 3}}, C(5), &mr);
+ auto m = mo;
assert(m.key_comp() == C(5));
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
auto [ks, vs] = std::move(m).extract();
assert(ks.get_allocator().resource() == std::pmr::get_default_resource());
assert(vs.get_allocator().resource() == std::pmr::get_default_resource());
// mo is unchanged
assert(mo.key_comp() == C(5));
- assert((mo == M{{1,1}, {2,2}, {3,3}}));
+ assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
auto [kso, vso] = std::move(mo).extract();
assert(kso.get_allocator().resource() == &mr);
assert(vso.get_allocator().resource() == &mr);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
index a7ff983a2219ce..91204f1688137c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
@@ -23,15 +23,14 @@
#include "../../../test_compare.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = test_less<int>;
std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
auto mo = M(ks, vs, C(5));
- auto m = M(mo, test_allocator<int>(3));
+ auto m = M(mo, test_allocator<int>(3));
assert(m.key_comp() == C(5));
assert(m.keys() == ks);
@@ -51,26 +50,26 @@ int main(int, char**)
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr1;
std::pmr::monotonic_buffer_resource mr2;
- M mo = M({1,2,3}, {2,2,1}, C(5), &mr1);
- M m = {mo, &mr2}; // also test the implicitness of this constructor
+ M mo = M({1, 2, 3}, {2, 2, 1}, C(5), &mr1);
+ M m = {mo, &mr2}; // also test the implicitness of this constructor
assert(m.key_comp() == C(5));
- assert((m.keys() == std::pmr::vector<int>{1,2,3}));
- assert((m.values() == std::pmr::vector<int>{2,2,1}));
+ assert((m.keys() == std::pmr::vector<int>{1, 2, 3}));
+ assert((m.values() == std::pmr::vector<int>{2, 2, 1}));
assert(m.keys().get_allocator().resource() == &mr2);
assert(m.values().get_allocator().resource() == &mr2);
// mo is unchanged
assert(mo.key_comp() == C(5));
- assert((mo.keys() == std::pmr::vector<int>{1,2,3}));
- assert((mo.values() == std::pmr::vector<int>{2,2,1}));
+ assert((mo.keys() == std::pmr::vector<int>{1, 2, 3}));
+ assert((mo.values() == std::pmr::vector<int>{2, 2, 1}));
assert(mo.keys().get_allocator().resource() == &mr1);
assert(mo.values().get_allocator().resource() == &mr1);
}
{
using M = std::flat_map<int, int, std::less<>, std::pmr::vector<int>, std::pmr::deque<int>>;
std::pmr::vector<M> vs;
- M m = {{1,2}, {2,2}, {3,1}};
+ M m = {{1, 2}, {2, 2}, {3, 1}};
vs.push_back(m);
assert(vs[0] == m);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
index 9b78fbd7a786c3..4f429bdc204c7a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
@@ -22,8 +22,7 @@
#include "../../../test_compare.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
// test_allocator is not propagated
using C = test_less<int>;
@@ -31,8 +30,8 @@ int main(int, char**)
std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
auto mo = M(ks, vs, C(5));
- auto m = M({{3,3}, {4,4}, {5,5}}, C(3), test_allocator<int>(2));
- m = mo;
+ auto m = M({{3, 3}, {4, 4}, {5, 5}}, C(3), test_allocator<int>(2));
+ m = mo;
assert(m.key_comp() == C(5));
assert(m.keys() == ks);
@@ -49,15 +48,15 @@ int main(int, char**)
}
{
// other_allocator is propagated
- using C = test_less<int>;
+ using C = test_less<int>;
using Ks = std::vector<int, other_allocator<int>>;
using Vs = std::vector<char, other_allocator<char>>;
- auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
- auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
- using M = std::flat_map<int, char, C, Ks, Vs>;
- auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
- auto m = M({{3,3}, {4,4}, {5,5}}, C(3), other_allocator<int>(2));
- m = mo;
+ auto ks = Ks({1, 3, 5}, other_allocator<int>(6));
+ auto vs = Vs({2, 2, 1}, other_allocator<char>(7));
+ using M = std::flat_map<int, char, C, Ks, Vs>;
+ auto mo = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
+ auto m = M({{3, 3}, {4, 4}, {5, 5}}, C(3), other_allocator<int>(2));
+ m = mo;
assert(m.key_comp() == C(5));
assert(m.keys() == ks);
@@ -77,22 +76,22 @@ int main(int, char**)
using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr1;
std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{1,1}, {2,2}, {3,3}}, &mr1);
- M m = M({{4,4}, {5,5}}, &mr2);
- m = mo;
- assert((m == M{{1,1}, {2,2}, {3,3}}));
+ M mo = M({{1, 1}, {2, 2}, {3, 3}}, &mr1);
+ M m = M({{4, 4}, {5, 5}}, &mr2);
+ m = mo;
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
assert(m.keys().get_allocator().resource() == &mr2);
assert(m.values().get_allocator().resource() == &mr2);
// mo is unchanged
- assert((mo == M{{1,1}, {2,2}, {3,3}}));
+ assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
assert(mo.keys().get_allocator().resource() == &mr1);
}
{
// comparator is copied and invariant is preserved
using M = std::flat_map<int, int, std::function<bool(int, int)>>;
- M mo = M({{1,2}, {3,4}}, std::less<int>());
- M m = M({{1,2}, {3,4}}, std::greater<int>());
+ M mo = M({{1, 2}, {3, 4}}, std::less<int>());
+ M m = M({{1, 2}, {3, 4}}, std::greater<int>());
assert(m.key_comp()(2, 1) == true);
assert(m != mo);
m = mo;
@@ -102,9 +101,9 @@ int main(int, char**)
{
// self-assignment
using M = std::flat_map<int, int>;
- M m = {{1,2}, {3,4}};
- m = static_cast<const M&>(m);
- assert((m == M{{1,2}, {3,4}}));
+ M m = {{1, 2}, {3, 4}};
+ m = static_cast<const M&>(m);
+ assert((m == M{{1, 2}, {3, 4}}));
}
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
index 56558bdf2e5f55..af15889a8cc678 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -27,24 +27,24 @@
#include "deduction_guides_sfinae_checks.h"
#include "test_allocator.h"
-using P = std::pair<int, long>;
+using P = std::pair<int, long>;
using PC = std::pair<const int, long>;
void test_copy() {
{
- std::flat_map<long, short> source = {{1,2}, {2,3}};
+ std::flat_map<long, short> source = {{1, 2}, {2, 3}};
std::flat_map s(source);
ASSERT_SAME_TYPE(decltype(s), decltype(source));
assert(s == source);
}
{
- std::flat_map<long, short, std::greater<long>> source = {{1,2}, {2,3}};
- std::flat_map s{ source }; // braces instead of parens
+ std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
+ std::flat_map s{source}; // braces instead of parens
ASSERT_SAME_TYPE(decltype(s), decltype(source));
assert(s == source);
}
{
- std::flat_map<long, short, std::greater<long>> source = {{1,2}, {2,3}};
+ std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
std::flat_map s(source, std::allocator<int>());
ASSERT_SAME_TYPE(decltype(s), decltype(source));
assert(s == source);
@@ -52,13 +52,11 @@ void test_copy() {
}
void test_containers() {
- std::deque<int, test_allocator<int>> ks({ 1, 2, 1, INT_MAX, 3 }, test_allocator<int>(0, 42));
- std::deque<short, test_allocator<short>> vs({ 1, 2, 1, 4, 5 }, test_allocator<int>(0, 43));
- std::deque<int, test_allocator<int>> sorted_ks({ 1, 2, 3, INT_MAX }, test_allocator<int>(0, 42));
- std::deque<short, test_allocator<short>> sorted_vs({ 1, 2, 5, 4 }, test_allocator<int>(0, 43));
- const std::pair<int, short> expected[] = {
- {1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}
- };
+ std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
{
std::flat_map s(ks, vs);
@@ -98,7 +96,8 @@ void test_containers() {
std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
std::flat_map s(std::move(pks), std::move(pvs), &mr2);
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().resource() == &mr2);
assert(s.values().get_allocator().resource() == &mr2);
@@ -110,7 +109,8 @@ void test_containers() {
std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().resource() == &mr2);
assert(s.values().get_allocator().resource() == &mr2);
@@ -118,13 +118,11 @@ void test_containers() {
}
void test_containers_compare() {
- std::deque<int, test_allocator<int>> ks({ 1, 2, 1, INT_MAX, 3 }, test_allocator<int>(0, 42));
- std::deque<short, test_allocator<short>> vs({ 1, 2, 1, 4, 5 }, test_allocator<int>(0, 43));
- std::deque<int, test_allocator<int>> sorted_ks({ INT_MAX, 3, 2, 1 }, test_allocator<int>(0, 42));
- std::deque<short, test_allocator<short>> sorted_vs({ 4, 5, 2, 1 }, test_allocator<int>(0, 43));
- const std::pair<int, short> expected[] = {
- {INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}
- };
+ std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
{
std::flat_map s(ks, vs, std::greater<int>());
@@ -164,7 +162,8 @@ void test_containers_compare() {
std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().resource() == &mr2);
assert(s.values().get_allocator().resource() == &mr2);
@@ -176,7 +175,8 @@ void test_containers_compare() {
std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().resource() == &mr2);
assert(s.values().get_allocator().resource() == &mr2);
@@ -184,10 +184,10 @@ void test_containers_compare() {
}
void test_iter_iter() {
- const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
- const P sorted_arr[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
- const PC arrc[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
- const PC sorted_arrc[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+ const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
+ const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
+ const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
+ const PC sorted_arrc[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
{
std::flat_map m(std::begin(arr), std::end(arr));
@@ -212,7 +212,7 @@ void test_iter_iter() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
assert(std::ranges::equal(m, sorted_arr));
}
- #if 0
+#if 0
{
std::flat_map m(std::begin(arr), std::end(arr), test_allocator<short>(0, 44));
@@ -245,7 +245,7 @@ void test_iter_iter() {
assert(m.keys().get_allocator().get_id() == 44);
assert(m.values().get_allocator().get_id() == 44);
}
- #endif
+#endif
{
std::flat_map<int, short> mo;
std::flat_map m(mo.begin(), mo.end());
@@ -259,11 +259,11 @@ void test_iter_iter() {
}
void test_iter_iter_compare() {
- const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
- const P sorted_arr[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
- const PC arrc[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
- const PC sorted_arrc[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
- using C = std::greater<long long>;
+ const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
+ const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
+ const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
+ const PC sorted_arrc[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
+ using C = std::greater<long long>;
{
std::flat_map m(std::begin(arr), std::end(arr), C());
@@ -288,7 +288,7 @@ void test_iter_iter_compare() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
assert(std::ranges::equal(m, sorted_arr));
}
- #if 0
+#if 0
{
std::flat_map m(std::begin(arr), std::end(arr), C(), test_allocator<short>(0, 44));
@@ -321,7 +321,7 @@ void test_iter_iter_compare() {
assert(m.keys().get_allocator().get_id() == 44);
assert(m.values().get_allocator().get_id() == 44);
}
- #endif
+#endif
{
std::flat_map<int, short> mo;
std::flat_map m(mo.begin(), mo.end(), C());
@@ -335,20 +335,20 @@ void test_iter_iter_compare() {
}
void test_initializer_list() {
- const P sorted_arr[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+ const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
{
- std::flat_map m{ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+ std::flat_map m{std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
assert(std::ranges::equal(m, sorted_arr));
}
{
- std::flat_map m(std::sorted_unique, { std::pair{1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} });
+ std::flat_map m(std::sorted_unique, {std::pair{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}});
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
assert(std::ranges::equal(m, sorted_arr));
}
- #if 0
+#if 0
{
std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, test_allocator<long>(0, 42));
@@ -365,25 +365,25 @@ void test_initializer_list() {
assert(m.keys().get_allocator().get_id() == 42);
assert(m.values().get_allocator().get_id() == 42);
}
- #endif
+#endif
}
void test_initializer_list_compare() {
- const P sorted_arr[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
- using C = std::greater<long long>;
+ const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
+ using C = std::greater<long long>;
{
- std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C());
+ std::flat_map m({std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}}, C());
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
assert(std::ranges::equal(m, sorted_arr));
}
{
- std::flat_map m(std::sorted_unique, { std::pair{INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} }, C());
+ std::flat_map m(std::sorted_unique, {std::pair{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}}, C());
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
assert(std::ranges::equal(m, sorted_arr));
}
- #if 0
+#if 0
{
std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C(), test_allocator<long>(0, 42));
@@ -400,12 +400,12 @@ void test_initializer_list_compare() {
assert(m.keys().get_allocator().get_id() == 42);
assert(m.values().get_allocator().get_id() == 42);
}
- #endif
+#endif
}
void test_from_range() {
- std::list<std::pair<int, short>> r = { {1,1}, {2,2}, {1,1}, {INT_MAX,4}, {3,5} };
- const std::pair<int, short> expected[] = { {1,1}, {2,2}, {3,5}, {INT_MAX,4} };
+ std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
+ const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
{
std::flat_map s(std::from_range, r);
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);
@@ -413,7 +413,13 @@ void test_from_range() {
}
{
std::flat_map s(std::from_range, r, test_allocator<long>(0, 42));
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<short, test_allocator<short>>>);
+ ASSERT_SAME_TYPE(
+ decltype(s),
+ std::flat_map<int,
+ short,
+ std::less<int>,
+ std::vector<int, test_allocator<int>>,
+ std::vector<short, test_allocator<short>>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().get_id() == 42);
assert(s.values().get_allocator().get_id() == 42);
@@ -421,8 +427,8 @@ void test_from_range() {
}
void test_from_range_compare() {
- std::list<std::pair<int, short>> r = { {1,1}, {2,2}, {1,1}, {INT_MAX,4}, {3,5} };
- const std::pair<int, short> expected[] = { {INT_MAX,4}, {3,5}, {2,2}, {1,1} };
+ std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
+ const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
{
std::flat_map s(std::from_range, r, std::greater<int>());
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);
@@ -430,15 +436,20 @@ void test_from_range_compare() {
}
{
std::flat_map s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
- ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, std::vector<int, test_allocator<int>>, std::vector<short, test_allocator<short>>>);
+ ASSERT_SAME_TYPE(
+ decltype(s),
+ std::flat_map<int,
+ short,
+ std::greater<int>,
+ std::vector<int, test_allocator<int>>,
+ std::vector<short, test_allocator<short>>>);
assert(std::ranges::equal(s, expected));
assert(s.keys().get_allocator().get_id() == 42);
assert(s.values().get_allocator().get_id() == 42);
}
}
-int main(int, char **)
-{
+int main(int, char**) {
// Each test function also tests the sorted_unique-prefixed and allocator-suffixed overloads.
test_copy();
test_containers();
@@ -453,34 +464,34 @@ int main(int, char **)
AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
{
- std::flat_map s = { std::make_pair(1, 'a') }; // flat_map(initializer_list<pair<int, char>>)
+ std::flat_map s = {std::make_pair(1, 'a')}; // flat_map(initializer_list<pair<int, char>>)
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, char>);
assert(s.size() == 1);
}
{
using M = std::flat_map<int, short>;
M m;
- std::flat_map s = { std::make_pair(m, m) }; // flat_map(initializer_list<pair<M, M>>)
+ std::flat_map s = {std::make_pair(m, m)}; // flat_map(initializer_list<pair<M, M>>)
ASSERT_SAME_TYPE(decltype(s), std::flat_map<M, M>);
assert(s.size() == 1);
assert(s[m] == m);
}
{
- std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
- std::flat_map s = { source, source + 3 }; // flat_map(InputIterator, InputIterator)
+ std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
+ std::flat_map s = {source, source + 3}; // flat_map(InputIterator, InputIterator)
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
assert(s.size() == 3);
}
{
- std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
- std::flat_map s{ source, source + 3 }; // flat_map(InputIterator, InputIterator)
+ std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
+ std::flat_map s{source, source + 3}; // flat_map(InputIterator, InputIterator)
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
assert(s.size() == 3);
}
{
- std::pair<int, int> source[3] = { {1,1}, {2,2}, {3,3} };
- std::flat_map s{ std::sorted_unique, source, source + 3 }; // flat_map(sorted_unique_t, InputIterator, InputIterator)
+ std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
+ std::flat_map s{std::sorted_unique, source, source + 3}; // flat_map(sorted_unique_t, InputIterator, InputIterator)
static_assert(std::is_same_v<decltype(s), std::flat_map<int, int>>);
assert(s.size() == 3);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
index 1213279a8e173a..8da08a968b362b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
@@ -22,7 +22,7 @@ struct NotAnAllocator {
friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; }
};
-using P = std::pair<int, long>;
+using P = std::pair<int, long>;
using PC = std::pair<const int, long>;
void test() {
@@ -30,68 +30,68 @@ void test() {
// cannot deduce Key and T from just (KeyContainer), even if it's a container of pairs
std::vector<std::pair<int, int>> v;
std::flat_map s(v);
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce Key and T from just (KeyContainer, Allocator)
std::vector<int> v;
std::flat_map s(v, std::allocator<std::pair<const int, int>>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce Key and T from nothing
std::flat_map m;
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce Key and T from just (Compare)
std::flat_map m(std::less<int>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce Key and T from just (Compare, Allocator)
std::flat_map m(std::less<int>{}, std::allocator<PC>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce Key and T from just (Allocator)
std::flat_map m(std::allocator<PC>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot convert from some arbitrary unrelated type
NotAnAllocator a;
std::flat_map m(a);
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
- std::flat_map m{ {1,1L}, {2,2L}, {3,3L} };
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m{{1, 1L}, {2, 2L}, {3, 3L}};
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
- std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::less<int>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
- std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::less<int>(), std::allocator<PC>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::less<int>(), std::allocator<PC>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
- std::flat_map m({ {1,1L}, {2,2L}, {3,3L} }, std::allocator<PC>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::allocator<PC>());
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// since we have parens, not braces, this deliberately does not find the initializer_list constructor
- std::flat_map m(P{1,1L});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m(P{1, 1L});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
{
// since we have parens, not braces, this deliberately does not find the initializer_list constructor
- std::flat_map m(PC{1,1L});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ std::flat_map m(PC{1, 1L});
+ // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
}
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
index 4d39c094f13764..8841571d6b112b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
@@ -29,8 +29,7 @@ struct DefaultCtableComp {
bool default_constructed_ = false;
};
-int main(int, char**)
-{
+int main(int, char**) {
{
std::flat_map<int, char*> m;
assert(m.empty());
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
index 2b920cd28c8783..ac24c8a8ac067e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp
@@ -28,12 +28,11 @@
#include "test_allocator.h"
struct ThrowingCtorComp {
- ThrowingCtorComp() noexcept(false) {}
- bool operator()(const auto&, const auto&) const { return false; }
+ ThrowingCtorComp() noexcept(false) {}
+ bool operator()(const auto&, const auto&) const { return false; }
};
-int main(int, char**)
-{
+int main(int, char**) {
#if defined(_LIBCPP_VERSION)
{
using C = std::flat_map<MoveOnly, MoveOnly>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
index 43f9dcedfd34af..e3ab33a55d95bf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp
@@ -27,8 +27,7 @@ struct ThrowingDtorComp {
~ThrowingDtorComp() noexcept(false);
};
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = std::flat_map<MoveOnly, MoveOnly>;
static_assert(std::is_nothrow_destructible_v<C>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
index 8e62164be72d7d..4a5a16e3058b8f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
@@ -30,36 +30,36 @@ struct DefaultCtableComp {
bool default_constructed_ = false;
};
-int main(int, char**)
-{
- std::pair<int, short> expected[] = {{1,1}, {2,2}, {3,3}, {5,2}};
+int main(int, char**) {
+ std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
{
using M = std::flat_map<int, short>;
- M m = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
- assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
}
{
using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
- M m = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
- assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
}
{
- using M = std::flat_map<int, short>;
- std::initializer_list<M::value_type> il = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
- M m = il;
- assert(std::equal(m.begin(), m.end(), expected, expected+4));
- static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>>);
- static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, std::allocator<int>>);
+ using M = std::flat_map<int, short>;
+ std::initializer_list<M::value_type> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ M m = il;
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>>);
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>>);
- static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
+ static_assert(
+ !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
}
{
using A = explicit_allocator<int>;
{
using M = std::flat_map<int, int, DefaultCtableComp, std::vector<int, A>, std::deque<int, A>>;
- M m = {{1,1}, {2,2}, {3,3}};
+ M m = {{1, 1}, {2, 2}, {3, 3}};
assert(m.size() == 1);
assert(m.begin()->first == m.begin()->second);
LIBCPP_ASSERT(*m.begin() == std::make_pair(1, 1));
@@ -68,17 +68,17 @@ int main(int, char**)
{
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
A a;
- M m({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, a);
- assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, a);
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
}
}
{
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::initializer_list<M::value_type> il = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
vm.emplace_back(il);
- assert((vm[0] == M{{1,1}, {3,3}, {4,4}, {5,5}}));
+ assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
index 10f42816bcdbc3..6c61bfcc57ffa0 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
@@ -25,52 +25,53 @@
#include "min_allocator.h"
#include "../../../test_compare.h"
-int main(int, char**)
-{
- std::pair<int, short> expected[] = {{1,1}, {2,2}, {3,3}, {5,2}};
+int main(int, char**) {
+ std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
{
using C = test_less<int>;
using M = std::flat_map<int, short, C>;
- auto m = M({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, C(10));
- assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
assert(m.key_comp() == C(10));
}
{
// Sorting uses the comparator that was passed in
using M = std::flat_map<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
- auto m = M({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, std::greater<int>());
- assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
assert(m.key_comp()(2, 1) == true);
}
{
- using C = test_less<int>;
- using M = std::flat_map<int, short, C>;
- std::initializer_list<M::value_type> il = {{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}};
- auto m = M(il, C(10));
- assert(std::equal(m.begin(), m.end(), expected, expected+4));
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C>;
+ std::initializer_list<M::value_type> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ auto m = M(il, C(10));
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
assert(m.key_comp() == C(10));
- static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C>);
- static_assert( std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C, std::allocator<int>>);
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C>);
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C>);
- static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C, std::allocator<int>>);
+ static_assert(
+ !std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C>);
- static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C, std::allocator<int>>);
+ static_assert(
+ !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C, std::allocator<int>>);
}
{
using A = explicit_allocator<int>;
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
A a;
- M m({{5,2}, {2,2}, {2,2}, {3,3}, {1,1}, {3,3}}, {}, a);
- assert(std::equal(m.rbegin(), m.rend(), expected, expected+4));
+ M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, {}, a);
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
}
{
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::initializer_list<M::value_type> il = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
vm.emplace_back(il, C(5));
- assert((vm[0] == M{{1,1}, {3,3}, {4,4}, {5,5}}));
+ assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
assert(vm[0].key_comp() == C(5));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
index 389d3906b5f97e..5f0b3be63ca70c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -27,34 +27,33 @@
#include "test_iterators.h"
#include "test_macros.h"
-int main(int, char**)
-{
- using P = std::pair<int, short>;
- P ar[] = {{1,1}, {1,2}, {1,3}, {2,4}, {2,5}, {3,6}, {2,7}, {3,8}, {3,9}};
- P expected[] = {{1,1}, {2,4}, {3,6}};
+int main(int, char**) {
+ using P = std::pair<int, short>;
+ P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
+ P expected[] = {{1, 1}, {2, 4}, {3, 6}};
{
using M = std::flat_map<int, short>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
}
{
using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<short>>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
- assert((m.keys() == std::deque<int, min_allocator<int>>{3,2,1}));
- LIBCPP_ASSERT((m.values() == std::deque<short>{6,4,1}));
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ assert((m.keys() == std::deque<int, min_allocator<int>>{3, 2, 1}));
+ LIBCPP_ASSERT((m.values() == std::deque<short>{6, 4, 1}));
}
{
// Test when the operands are of array type (also contiguous iterator type)
using M = std::flat_map<int, short, std::greater<int>, std::vector<int, min_allocator<int>>>;
- auto m = M(ar, ar);
+ auto m = M(ar, ar);
assert(m.empty());
}
{
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
- auto m = M(ar, ar + 9, A1(5));
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(ar, ar + 9, A1(5));
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
assert(m.keys().get_allocator() == A1(5));
@@ -63,10 +62,10 @@ int main(int, char**)
{
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
- M m = { ar, ar + 9, A1(5) }; // implicit ctor
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ M m = {ar, ar + 9, A1(5)}; // implicit ctor
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
index e2e264edd8e394..d18994082eb98f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
@@ -28,21 +28,20 @@
#include "test_macros.h"
#include "../../../test_compare.h"
-int main(int, char**)
-{
- using P = std::pair<int, short>;
- P ar[] = {{1,1}, {1,2}, {1,3}, {2,4}, {2,5}, {3,6}, {2,7}, {3,8}, {3,9}};
- P expected[] = {{1,1}, {2,4}, {3,6}};
+int main(int, char**) {
+ using P = std::pair<int, short>;
+ P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
+ P expected[] = {{1, 1}, {2, 4}, {3, 6}};
{
- using M = std::flat_map<int, short, std::function<bool(int,int)>>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::less<int>());
+ using M = std::flat_map<int, short, std::function<bool(int, int)>>;
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::less<int>());
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
assert(m.key_comp()(1, 2) == true);
}
{
using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::greater<int>());
+ auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::greater<int>());
assert(std::ranges::equal(m.keys(), expected | std::views::reverse | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected | std::views::reverse));
}
@@ -50,18 +49,18 @@ int main(int, char**)
// Test when the operands are of array type (also contiguous iterator type)
using C = test_less<int>;
using M = std::flat_map<int, short, C, std::vector<int, min_allocator<int>>>;
- auto m = M(ar, ar, C(5));
+ auto m = M(ar, ar, C(5));
assert(m.empty());
assert(m.key_comp() == C(5));
}
{
- using C = test_less<int>;
+ using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
- auto m = M(ar, ar + 9, C(3), A1(5));
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(ar, ar + 9, C(3), A1(5));
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
assert(m.key_comp() == C(3));
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
@@ -69,8 +68,8 @@ int main(int, char**)
{
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
- M m = { ar, ar + 9, {}, A2(5) }; // implicit ctor
+ using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
+ M m = {ar, ar + 9, {}, A2(5)}; // implicit ctor
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
assert(m.keys().get_allocator() == A1(5));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
index 6eb19ce0e2d956..1ce859f6c737ea 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_stability.pass.cpp
@@ -30,12 +30,11 @@ struct Mod256 {
bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
};
-int main(int, char**)
-{
+int main(int, char**) {
std::mt19937 randomness;
std::pair<uint16_t, uint16_t> pairs[200];
for (auto& pair : pairs) {
- pair = { uint16_t(randomness()), uint16_t(randomness()) };
+ pair = {uint16_t(randomness()), uint16_t(randomness())};
}
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
index 20f5c4268921ec..4cd24e3df9fb6b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
@@ -24,15 +24,14 @@
#include "test_allocator.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = test_less<int>;
using A = test_allocator<int>;
using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- M mo = M({{1,1},{2,2},{3,1}}, C(5), A(7));
- M m = std::move(mo);
- assert((m == M{{1,1},{2,2},{3,1}}));
+ M mo = M({{1, 1}, {2, 2}, {3, 1}}, C(5), A(7));
+ M m = std::move(mo);
+ assert((m == M{{1, 1}, {2, 2}, {3, 1}}));
assert(m.key_comp() == C(5));
assert(m.keys().get_allocator() == A(7));
assert(m.values().get_allocator() == A(7));
@@ -46,9 +45,9 @@ int main(int, char**)
using C = test_less<int>;
using A = min_allocator<int>;
using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- M mo = M({{1,1},{2,2},{3,1}}, C(5), A());
- M m = std::move(mo);
- assert((m == M{{1,1},{2,2},{3,1}}));
+ M mo = M({{1, 1}, {2, 2}, {3, 1}}, C(5), A());
+ M m = std::move(mo);
+ assert((m == M{{1, 1}, {2, 2}, {3, 1}}));
assert(m.key_comp() == C(5));
assert(m.keys().get_allocator() == A());
assert(m.values().get_allocator() == A());
@@ -60,17 +59,17 @@ int main(int, char**)
}
{
// A moved-from flat_map maintains its class invariant in the presence of moved-from comparators.
- using M = std::flat_map<int, int, std::function<bool(int,int)>>;
- M mo = M({{1,1},{2,2},{3,1}}, std::less<int>());
- M m = std::move(mo);
+ using M = std::flat_map<int, int, std::function<bool(int, int)>>;
+ M mo = M({{1, 1}, {2, 2}, {3, 1}}, std::less<int>());
+ M m = std::move(mo);
assert(m.size() == 3);
assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
- assert(m.key_comp()(1,2) == true);
+ assert(m.key_comp()(1, 2) == true);
assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- LIBCPP_ASSERT(m.key_comp()(1,2) == true);
+ LIBCPP_ASSERT(m.key_comp()(1, 2) == true);
LIBCPP_ASSERT(mo.empty());
- mo.insert({{1,1},{2,2},{3,1}}); // insert has no preconditions
+ mo.insert({{1, 1}, {2, 2}, {3, 1}}); // insert has no preconditions
assert(m == mo);
}
return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index 745680c063ee06..e225977c3eb9c3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -24,15 +24,14 @@
#include "../../../test_compare.h"
#include "test_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,1}};
- using C = test_less<int>;
- using A = test_allocator<int>;
- using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto mo = M(expected, expected + 3, C(5), A(7));
- auto m = M(std::move(mo), A(3));
+ std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
+ using C = test_less<int>;
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
+ auto mo = M(expected, expected + 3, C(5), A(7));
+ auto m = M(std::move(mo), A(3));
assert(m.key_comp() == C(5));
assert(m.size() == 3);
@@ -44,21 +43,21 @@ int main(int, char**)
// The original flat_map is moved-from.
assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- #if 0
+#if 0
assert(mo.empty());
- #endif
+#endif
assert(mo.key_comp() == C(5));
assert(mo.keys().get_allocator() == A(7));
assert(mo.values().get_allocator() == A(7));
}
{
- std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,1}};
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
std::pmr::monotonic_buffer_resource mr1;
std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{1,1}, {3,1}, {1,1}, {2,2}}, C(5), &mr1);
- M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor
+ M mo = M({{1, 1}, {3, 1}, {1, 1}, {2, 2}}, C(5), &mr1);
+ M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor
assert(m.key_comp() == C(5));
assert(m.size() == 3);
@@ -75,10 +74,10 @@ int main(int, char**)
{
using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
std::pmr::vector<M> vs;
- M m = {{1,1}, {3,1}, {1,1}, {2,2}};
+ M m = {{1, 1}, {3, 1}, {1, 1}, {2, 2}};
vs.push_back(std::move(m));
- assert((vs[0].keys() == std::pmr::deque<int>{1,2,3}));
- assert((vs[0].values() == std::pmr::vector<int>{1,2,1}));
+ assert((vs[0].keys() == std::pmr::deque<int>{1, 2, 3}));
+ assert((vs[0].values() == std::pmr::vector<int>{1, 2, 1}));
}
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
index bf0b0e71a3a827..e29c175500671d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
@@ -27,17 +27,16 @@
#include "test_allocator.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using C = test_less<int>;
+ using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<char>;
- using M = std::flat_map<int, char, C, std::vector<int, A1>, std::vector<char, A2>>;
- M mo = M({{1,1},{2,3},{3,2}}, C(5), A1(7));
- M m = M({}, C(3), A1(7));
- m = std::move(mo);
- assert((m == M{{1,1},{2,3},{3,2}}));
+ using M = std::flat_map<int, char, C, std::vector<int, A1>, std::vector<char, A2>>;
+ M mo = M({{1, 1}, {2, 3}, {3, 2}}, C(5), A1(7));
+ M m = M({}, C(3), A1(7));
+ m = std::move(mo);
+ assert((m == M{{1, 1}, {2, 3}, {3, 2}}));
assert(m.key_comp() == C(5));
auto [ks, vs] = std::move(m).extract();
assert(ks.get_allocator() == A1(7));
@@ -45,14 +44,14 @@ int main(int, char**)
assert(mo.empty());
}
{
- using C = test_less<int>;
+ using C = test_less<int>;
using A1 = other_allocator<int>;
using A2 = other_allocator<char>;
- using M = std::flat_map<int, char, C, std::deque<int, A1>, std::deque<char, A2>>;
- M mo = M({{4,5},{5,4}}, C(5), A1(7));
- M m = M({{1,1},{2,2},{3,3},{4,4}}, C(3), A1(7));
- m = std::move(mo);
- assert((m == M{{4,5},{5,4}}));
+ using M = std::flat_map<int, char, C, std::deque<int, A1>, std::deque<char, A2>>;
+ M mo = M({{4, 5}, {5, 4}}, C(5), A1(7));
+ M m = M({{1, 1}, {2, 2}, {3, 3}, {4, 4}}, C(3), A1(7));
+ m = std::move(mo);
+ assert((m == M{{4, 5}, {5, 4}}));
assert(m.key_comp() == C(5));
auto [ks, vs] = std::move(m).extract();
assert(ks.get_allocator() == A1(7));
@@ -62,10 +61,10 @@ int main(int, char**)
{
using A = min_allocator<int>;
using M = std::flat_map<int, int, std::greater<int>, std::vector<int, A>, std::vector<int, A>>;
- M mo = M({{5,1},{4,2},{3,3}}, A());
- M m = M({{4,4},{3,3},{2,2},{1,1}}, A());
- m = std::move(mo);
- assert((m == M{{5,1},{4,2},{3,3}}));
+ M mo = M({{5, 1}, {4, 2}, {3, 3}}, A());
+ M m = M({{4, 4}, {3, 3}, {2, 2}, {1, 1}}, A());
+ m = std::move(mo);
+ assert((m == M{{5, 1}, {4, 2}, {3, 3}}));
auto [ks, vs] = std::move(m).extract();
assert(ks.get_allocator() == A());
assert(vs.get_allocator() == A());
@@ -73,35 +72,38 @@ int main(int, char**)
}
{
// A moved-from flat_map maintains its class invariant in the presence of moved-from elements.
- using M = std::flat_map<std::pmr::string, int, std::less<>, std::pmr::vector<std::pmr::string>, std::pmr::vector<int>>;
+ using M =
+ std::flat_map<std::pmr::string, int, std::less<>, std::pmr::vector<std::pmr::string>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr1;
std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{"short", 1}, {"very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move", 2}}, &mr1);
- M m = M({{"don't care", 3}}, &mr2);
- m = std::move(mo);
+ M mo = M({{"short", 1},
+ {"very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move", 2}},
+ &mr1);
+ M m = M({{"don't care", 3}}, &mr2);
+ m = std::move(mo);
assert(m.size() == 2);
assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
assert(m.begin()->first.get_allocator().resource() == &mr2);
assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- mo.insert({"foo",1});
+ mo.insert({"foo", 1});
assert(mo.begin()->first.get_allocator().resource() == &mr1);
}
{
// A moved-from flat_map maintains its class invariant in the presence of moved-from comparators.
- using C = std::function<bool(int,int)>;
+ using C = std::function<bool(int, int)>;
using M = std::flat_map<int, int, C>;
- M mo = M({{1,3},{2,2},{3,1}}, std::less<int>());
- M m = M({{1,1},{2,2}}, std::greater<int>());
- m = std::move(mo);
+ M mo = M({{1, 3}, {2, 2}, {3, 1}}, std::less<int>());
+ M m = M({{1, 1}, {2, 2}}, std::greater<int>());
+ m = std::move(mo);
assert(m.size() == 3);
assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
- assert(m.key_comp()(1,2) == true);
+ assert(m.key_comp()(1, 2) == true);
assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- LIBCPP_ASSERT(m.key_comp()(1,2) == true);
+ LIBCPP_ASSERT(m.key_comp()(1, 2) == true);
LIBCPP_ASSERT(mo.empty());
- mo.insert({{1,3},{2,2},{3,1}}); // insert has no preconditions
+ mo.insert({{1, 3}, {2, 2}, {3, 1}}); // insert has no preconditions
LIBCPP_ASSERT(m == mo);
}
return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
index 95fcb1e5e0c273..de15377d862fff 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
@@ -24,59 +24,66 @@
#include "test_macros.h"
struct MoveNegates {
- int value_ = 0;
- MoveNegates() = default;
- MoveNegates(int v) : value_(v) {}
- MoveNegates(MoveNegates&& rhs) : value_(rhs.value_) { rhs.value_ = -rhs.value_; }
- MoveNegates& operator=(MoveNegates&& rhs) { value_ = rhs.value_; rhs.value_ = -rhs.value_; return *this; }
- ~MoveNegates() = default;
- auto operator<=>(const MoveNegates&) const = default;
+ int value_ = 0;
+ MoveNegates() = default;
+ MoveNegates(int v) : value_(v) {}
+ MoveNegates(MoveNegates&& rhs) : value_(rhs.value_) { rhs.value_ = -rhs.value_; }
+ MoveNegates& operator=(MoveNegates&& rhs) {
+ value_ = rhs.value_;
+ rhs.value_ = -rhs.value_;
+ return *this;
+ }
+ ~MoveNegates() = default;
+ auto operator<=>(const MoveNegates&) const = default;
};
struct MoveClears {
- int value_ = 0;
- MoveClears() = default;
- MoveClears(int v) : value_(v) {}
- MoveClears(MoveClears&& rhs) : value_(rhs.value_) { rhs.value_ = 0; }
- MoveClears& operator=(MoveClears&& rhs) { value_ = rhs.value_; rhs.value_ = 0; return *this; }
- ~MoveClears() = default;
- auto operator<=>(const MoveClears&) const = default;
+ int value_ = 0;
+ MoveClears() = default;
+ MoveClears(int v) : value_(v) {}
+ MoveClears(MoveClears&& rhs) : value_(rhs.value_) { rhs.value_ = 0; }
+ MoveClears& operator=(MoveClears&& rhs) {
+ value_ = rhs.value_;
+ rhs.value_ = 0;
+ return *this;
+ }
+ ~MoveClears() = default;
+ auto operator<=>(const MoveClears&) const = default;
};
-int main(int, char**)
-{
+int main(int, char**) {
auto value_eq = [](auto&& p, auto&& q) { return p.first == q.first; };
{
- const std::pair<int, int> expected[] = { {1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8} };
+ const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
using M = std::flat_map<MoveNegates, int, std::less<MoveNegates>, std::vector<MoveNegates>>;
- M m = M(expected, expected + 8);
- M m2 = M(expected, expected + 3);
+ M m = M(expected, expected + 8);
+ M m2 = M(expected, expected + 3);
m2 = std::move(m);
- assert(std::equal(m2.begin(), m2.end(), expected, expected+8));
+ assert(std::equal(m2.begin(), m2.end(), expected, expected + 8));
LIBCPP_ASSERT(m.empty());
- assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
assert(std::adjacent_find(m.begin(), m.end(), value_eq) == m.end()); // still contains no duplicates
- m.insert({1,1});
- m.insert({2,2});
+ m.insert({1, 1});
+ m.insert({2, 2});
assert(m.contains(1));
assert(m.find(2) != m.end());
}
{
- const std::pair<int, int> expected[] = { {1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8} };
+ const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
using M = std::flat_map<MoveClears, int, std::less<MoveClears>, std::vector<MoveClears>>;
- M m = M(expected, expected + 8);
- M m2 = M(expected, expected + 3);
+ M m = M(expected, expected + 8);
+ M m2 = M(expected, expected + 3);
m2 = std::move(m);
- assert(std::equal(m2.begin(), m2.end(), expected, expected+8));
+ assert(std::equal(m2.begin(), m2.end(), expected, expected + 8));
LIBCPP_ASSERT(m.empty());
- assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); // still sorted
assert(std::adjacent_find(m.begin(), m.end(), value_eq) == m.end()); // still contains no duplicates
- m.insert({1,1});
- m.insert({2,2});
+ m.insert({1, 1});
+ m.insert({2, 2});
assert(m.contains(1));
assert(m.find(2) != m.end());
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
index 5c9514089cb55b..763dcd051c104a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
@@ -29,40 +29,62 @@
#include "test_macros.h"
struct MoveSensitiveComp {
- MoveSensitiveComp() noexcept(false) = default;
+ MoveSensitiveComp() noexcept(false) = default;
MoveSensitiveComp(const MoveSensitiveComp&) noexcept(false) = default;
MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; }
MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept = default;
- MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; return *this; }
+ MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) {
+ rhs.is_moved_from_ = true;
+ return *this;
+ }
bool operator()(const auto&, const auto&) const { return false; }
bool is_moved_from_ = false;
};
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = std::flat_map<int, int>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
}
{
- using C = std::flat_map<MoveOnly, int, std::less<MoveOnly>, std::vector<MoveOnly, test_allocator<MoveOnly>>, std::vector<int, test_allocator<int>>>;
+ using C =
+ std::flat_map<MoveOnly,
+ int,
+ std::less<MoveOnly>,
+ std::vector<MoveOnly, test_allocator<MoveOnly>>,
+ std::vector<int, test_allocator<int>>>;
static_assert(!std::is_nothrow_move_assignable_v<C>);
}
{
- using C = std::flat_map<int, MoveOnly, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<MoveOnly, test_allocator<MoveOnly>>>;
+ using C =
+ std::flat_map<int,
+ MoveOnly,
+ std::less<int>,
+ std::vector<int, test_allocator<int>>,
+ std::vector<MoveOnly, test_allocator<MoveOnly>>>;
static_assert(!std::is_nothrow_move_assignable_v<C>);
}
{
- using C = std::flat_map<MoveOnly, int, std::less<MoveOnly>, std::vector<MoveOnly, other_allocator<MoveOnly>>, std::vector<int, other_allocator<int>>>;
+ using C =
+ std::flat_map<MoveOnly,
+ int,
+ std::less<MoveOnly>,
+ std::vector<MoveOnly, other_allocator<MoveOnly>>,
+ std::vector<int, other_allocator<int>>>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
}
{
- using C = std::flat_map<int, MoveOnly, std::less<int>, std::vector<int, other_allocator<int>>, std::vector<MoveOnly, other_allocator<MoveOnly>>>;
+ using C =
+ std::flat_map<int,
+ MoveOnly,
+ std::less<int>,
+ std::vector<int, other_allocator<int>>,
+ std::vector<MoveOnly, other_allocator<MoveOnly>>>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
}
{
// Test with a comparator that throws on copy-assignment.
- using C = std::flat_map<int, int, std::function<bool(int,int)>>;
+ using C = std::flat_map<int, int, std::function<bool(int, int)>>;
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v<C>);
}
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
index 2e7d5c95a08d14..f052ba3ca7ed1d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
@@ -38,11 +38,10 @@ struct EvilContainer : std::vector<int> {
}
};
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, int, std::less<int>, EvilContainer, std::vector<int>>;
- M mo = {{1,1}, {2,2}, {3,3}};
+ using M = std::flat_map<int, int, std::less<int>, EvilContainer, std::vector<int>>;
+ M mo = {{1, 1}, {2, 2}, {3, 3}};
countdown = 1;
try {
M m = std::move(mo);
@@ -57,8 +56,8 @@ int main(int, char**)
LIBCPP_ASSERT(mo.empty());
}
{
- using M = std::flat_map<int, int, std::less<int>, std::vector<int>, EvilContainer>;
- M mo = {{1,1}, {2,2}, {3,3}};
+ using M = std::flat_map<int, int, std::less<int>, std::vector<int>, EvilContainer>;
+ M mo = {{1, 1}, {2, 2}, {3, 3}};
countdown = 1;
try {
M m = std::move(mo);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
index ee7798b8738f12..c170f0fd758274 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
@@ -31,12 +31,12 @@
template <class T>
struct ThrowingMoveAllocator {
- using value_type = T;
- explicit ThrowingMoveAllocator() = default;
+ using value_type = T;
+ explicit ThrowingMoveAllocator() = default;
ThrowingMoveAllocator(const ThrowingMoveAllocator&) = default;
ThrowingMoveAllocator(ThrowingMoveAllocator&&) noexcept(false) {}
- T *allocate(std::ptrdiff_t n) { return std::allocator<T>().allocate(n); }
- void deallocate(T *p, std::ptrdiff_t n) { return std::allocator<T>().deallocate(p, n); }
+ T* allocate(std::ptrdiff_t n) { return std::allocator<T>().allocate(n); }
+ void deallocate(T* p, std::ptrdiff_t n) { return std::allocator<T>().deallocate(p, n); }
friend bool operator==(ThrowingMoveAllocator, ThrowingMoveAllocator) = default;
};
@@ -48,17 +48,19 @@ struct ThrowingCopyComp {
};
struct MoveSensitiveComp {
- MoveSensitiveComp() noexcept(false) = default;
+ MoveSensitiveComp() noexcept(false) = default;
MoveSensitiveComp(const MoveSensitiveComp&) noexcept = default;
MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; }
MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept(false) = default;
- MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; return *this; }
+ MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) {
+ rhs.is_moved_from_ = true;
+ return *this;
+ }
bool operator()(const auto&, const auto&) const { return false; }
bool is_moved_from_ = false;
};
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = std::flat_map<int, int>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index 106885cdd36b8b..eeb536f5277653 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -25,53 +25,52 @@
#include "test_iterators.h"
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, char>;
- std::vector<int> ks = {1,2,4,10};
- std::vector<char> vs = {4,3,2,1};
- auto m = M(std::sorted_unique, ks, vs);
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ using M = std::flat_map<int, char>;
+ std::vector<int> ks = {1, 2, 4, 10};
+ std::vector<char> vs = {4, 3, 2, 1};
+ auto m = M(std::sorted_unique, ks, vs);
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
m = M(std::sorted_unique, std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
}
{
using Ks = std::deque<int, min_allocator<int>>;
using Vs = std::deque<char, min_allocator<char>>;
- using M = std::flat_map<int, char, std::greater<int>, Ks, Vs>;
- Ks ks = {10,4,2,1};
- Vs vs = {1,2,3,4};
- auto m = M(std::sorted_unique, ks, vs);
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ using M = std::flat_map<int, char, std::greater<int>, Ks, Vs>;
+ Ks ks = {10, 4, 2, 1};
+ Vs vs = {1, 2, 3, 4};
+ auto m = M(std::sorted_unique, ks, vs);
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
m = M(std::sorted_unique, std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
}
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,2,4,10}, A(4));
- auto vs = std::deque<int, A>({4,3,2,1}, A(5));
- auto m = M(std::sorted_unique, std::move(ks), std::move(vs));
+ auto ks = std::vector<int, A>({1, 2, 4, 10}, A(4));
+ auto vs = std::deque<int, A>({4, 3, 2, 1}, A(5));
+ auto m = M(std::sorted_unique, std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(m.keys().get_allocator() == A(4));
assert(m.values().get_allocator() == A(5));
}
{
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1,2,4,10}, A(4));
- auto vs = std::deque<int, A>({4,3,2,1}, A(5));
- auto m = M(std::sorted_unique, ks, vs, A(6)); // replaces the allocators
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ auto ks = std::vector<int, A>({1, 2, 4, 10}, A(4));
+ auto vs = std::deque<int, A>({4, 3, 2, 1}, A(5));
+ auto m = M(std::sorted_unique, ks, vs, A(6)); // replaces the allocators
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(m.keys().get_allocator() == A(6));
assert(m.values().get_allocator() == A(6));
}
@@ -79,12 +78,12 @@ int main(int, char**)
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,2,4,10};
- std::pmr::vector<int> vs = {4,3,2,1};
+ std::pmr::vector<int> ks = {1, 2, 4, 10};
+ std::pmr::vector<int> vs = {4, 3, 2, 1};
vm.emplace_back(std::sorted_unique, ks, vs);
assert(!ks.empty()); // it was an lvalue above
assert(!vs.empty()); // it was an lvalue above
- assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
@@ -92,16 +91,16 @@ int main(int, char**)
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1,2,4,10};
- std::pmr::vector<int> vs = {4,3,2,1};
+ std::pmr::vector<int> ks = {1, 2, 4, 10};
+ std::pmr::vector<int> vs = {4, 3, 2, 1};
vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
LIBCPP_ASSERT(ks.size() == 4); // ks' size is unchanged, since it uses a different allocator
LIBCPP_ASSERT(vs.size() == 4); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
- #if 0
+#if 0
{
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
@@ -124,6 +123,6 @@ int main(int, char**)
assert(vm.size() == 1);
assert(vm[0].empty());
}
- #endif
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
index b5852d40ea9104..3eebfc2d099160 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
@@ -27,41 +27,46 @@
#include "test_macros.h"
#include "../../../test_compare.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using M = std::flat_map<int, int, std::function<bool(int,int)>>;
+ using M = std::flat_map<int, int, std::function<bool(int, int)>>;
using P = std::pair<int, int>;
- P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
- auto m = M(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), std::less<int>());
- assert(m == M({{1,1}, {2,2}, {4,4}, {5,5}}, std::less<>()));
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ auto m = M(std::sorted_unique,
+ cpp17_input_iterator<const P*>(ar),
+ cpp17_input_iterator<const P*>(ar + 4),
+ std::less<int>());
+ assert(m == M({{1, 1}, {2, 2}, {4, 4}, {5, 5}}, std::less<>()));
assert(m.key_comp()(1, 2) == true);
}
{
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int>>;
using P = std::pair<int, int>;
- P ar[] = {{5,5}, {4,4}, {2,2}, {1,1}};
- auto m = M(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), std::greater<int>());
- assert((m == M{{5,5}, {4,4}, {2,2}, {1,1}}));
+ P ar[] = {{5, 5}, {4, 4}, {2, 2}, {1, 1}};
+ auto m = M(std::sorted_unique,
+ cpp17_input_iterator<const P*>(ar),
+ cpp17_input_iterator<const P*>(ar + 4),
+ std::greater<int>());
+ assert((m == M{{5, 5}, {4, 4}, {2, 2}, {1, 1}}));
}
{
// Test when the operands are of array type (also contiguous iterator type)
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
- std::pair<int, int> ar[1] = {{42,42}};
- auto m = M(std::sorted_unique, ar, ar, C(5));
+ std::pair<int, int> ar[1] = {{42, 42}};
+ auto m = M(std::sorted_unique, ar, ar, C(5));
assert(m.empty());
assert(m.key_comp() == C(5));
}
{
- using C = test_less<int>;
+ using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
- using P = std::pair<int, int>;
- P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
- auto m = M(std::sorted_unique, ar, ar + 4, C(3), A1(5));
- assert((m == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ auto m = M(std::sorted_unique, ar, ar + 4, C(3), A1(5));
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
assert(m.key_comp() == C(3));
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
@@ -69,11 +74,11 @@ int main(int, char**)
{
using A1 = test_allocator<short>;
using A2 = test_allocator<int>;
- using M = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
- using P = std::pair<int, int>;
- P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
- M m = { std::sorted_unique, ar, ar + 4, {}, A1(5) }; // implicit ctor
- assert((m == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ using M = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ M m = {std::sorted_unique, ar, ar + 4, {}, A1(5)}; // implicit ctor
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
@@ -83,9 +88,10 @@ int main(int, char**)
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
using P = std::pair<int, int>;
- P ar[] = {{1,1}, {2,2}, {4,4}, {5,5}};
- vm.emplace_back(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
- assert((vm[0] == M{{1,1}, {2,2}, {4,4}, {5,5}}));
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ vm.emplace_back(
+ std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
assert(vm[0].key_comp() == C(3));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
@@ -95,7 +101,7 @@ int main(int, char**)
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pair<int, int> ar[1] = {{42,42}};
+ std::pair<int, int> ar[1] = {{42, 42}};
vm.emplace_back(std::sorted_unique, ar, ar, C(4));
assert(vm[0] == M{});
assert(vm[0].key_comp() == C(4));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
index c11aea1364e3a4..e225285e8d8259 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
@@ -27,23 +27,21 @@
// Verify that `flat_map` (like `map`) does NOT support std::erase.
//
template <class S>
-concept HasStdErase = requires (S& s, typename S::value_type x) {
- std::erase(s, x);
-};
+concept HasStdErase = requires(S& s, typename S::value_type x) { std::erase(s, x); };
static_assert(HasStdErase<std::vector<int>>);
static_assert(!HasStdErase<std::flat_map<int, int>>);
template <class M>
-M make(std::initializer_list<int> vals)
-{
- M ret;
- for (int v : vals)
- ret[static_cast<typename M::key_type>(v)] = static_cast<typename M::mapped_type>(v + 10);
- return ret;
+M make(std::initializer_list<int> vals) {
+ M ret;
+ for (int v : vals)
+ ret[static_cast<typename M::key_type>(v)] = static_cast<typename M::mapped_type>(v + 10);
+ return ret;
}
template <class M, class Pred>
-void test0(std::initializer_list<int> vals, Pred p, std::initializer_list<int> expected, std::size_t expected_erased_count) {
+void test0(
+ std::initializer_list<int> vals, Pred p, std::initializer_list<int> expected, std::size_t expected_erased_count) {
M s = make<M>(vals);
ASSERT_SAME_TYPE(typename M::size_type, decltype(std::erase_if(s, p)));
assert(expected_erased_count == std::erase_if(s, p));
@@ -51,48 +49,50 @@ void test0(std::initializer_list<int> vals, Pred p, std::initializer_list<int> e
}
template <class S>
-void test()
-{
- // Test all the plausible signatures for this predicate.
- auto is1 = [](typename S::const_reference v) { return v.first == 1;};
- auto is2 = [](typename S::value_type v) { return v.first == 2;};
- auto is3 = [](const typename S::value_type& v) { return v.first == 3;};
- auto is4 = [](auto v) { return v.first == 4;};
- auto True = [](const auto&) { return true; };
- auto False = [](auto&&) { return false; };
+void test() {
+ // Test all the plausible signatures for this predicate.
+ auto is1 = [](typename S::const_reference v) { return v.first == 1; };
+ auto is2 = [](typename S::value_type v) { return v.first == 2; };
+ auto is3 = [](const typename S::value_type& v) { return v.first == 3; };
+ auto is4 = [](auto v) { return v.first == 4; };
+ auto True = [](const auto&) { return true; };
+ auto False = [](auto&&) { return false; };
- test0<S>({}, is1, {}, 0);
+ test0<S>({}, is1, {}, 0);
- test0<S>({1}, is1, {}, 1);
- test0<S>({1}, is2, {1}, 0);
+ test0<S>({1}, is1, {}, 1);
+ test0<S>({1}, is2, {1}, 0);
- test0<S>({1, 2}, is1, {2}, 1);
- test0<S>({1, 2}, is2, {1}, 1);
- test0<S>({1, 2}, is3, {1, 2}, 0);
+ test0<S>({1, 2}, is1, {2}, 1);
+ test0<S>({1, 2}, is2, {1}, 1);
+ test0<S>({1, 2}, is3, {1, 2}, 0);
- test0<S>({1, 2, 3}, is1, {2, 3}, 1);
- test0<S>({1, 2, 3}, is2, {1, 3}, 1);
- test0<S>({1, 2, 3}, is3, {1, 2}, 1);
- test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
+ test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+ test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+ test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+ test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
- test0<S>({1, 2, 3}, True, {}, 3);
- test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
+ test0<S>({1, 2, 3}, True, {}, 3);
+ test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
}
-int main(int, char**)
-{
+int main(int, char**) {
test<std::flat_map<int, char>>();
- test<std::flat_map<int, char, std::less<int>, std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>>();
+ test<std::flat_map<int,
+ char,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<char, min_allocator<char>>>>();
test<std::flat_map<int, char, std::greater<int>, std::vector<int, test_allocator<int>>>>();
test<std::flat_map<int, char, std::less<int>, std::deque<int, min_allocator<int>>>>();
test<std::flat_map<int, char, std::greater<int>, std::deque<int, test_allocator<int>>>>();
test<std::flat_map<long, int>>();
test<std::flat_map<double, int>>();
{
- using M = std::flat_map<bool, bool>;
- std::flat_map<bool, bool> fs = {{true,false}, {false,true}};
- std::same_as<size_t> auto n = std::erase_if(fs, [](M::const_reference x) { return x.first; });
- assert((fs == M{{false,true}}));
+ using M = std::flat_map<bool, bool>;
+ std::flat_map<bool, bool> fs = {{true, false}, {false, true}};
+ std::same_as<size_t> auto n = std::erase_if(fs, [](M::const_reference x) { return x.first; });
+ assert((fs == M{{false, true}}));
assert(n == 1);
n = std::erase_if(fs, [](const M::value_type& x) { return !x.first; });
assert(fs.empty());
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
index fcda037112f941..ef76e1c6192ec1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
@@ -38,7 +38,7 @@ struct Counter {
}
}
};
-Counter g_counter = {0,0,0};
+Counter g_counter = {0, 0, 0};
struct ThrowingAssignment {
ThrowingAssignment(int i) : i_(i) {}
@@ -61,35 +61,32 @@ struct ThrowingComparator {
};
struct ErasurePredicate {
- bool operator()(const auto& x) const {
- return (3 <= x.first && x.first <= 5);
- }
+ bool operator()(const auto& x) const { return (3 <= x.first && x.first <= 5); }
};
-int main(int, char**)
-{
- const std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}};
+int main(int, char**) {
+ const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
{
using M = std::flat_map<ThrowingAssignment, int, ThrowingComparator>;
for (int first_throw = 1; first_throw < 99; ++first_throw) {
for (int second_throw = 1; second_throw < 99; ++second_throw) {
- g_counter = {0,0,0};
- M m = M({1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8});
+ g_counter = {0, 0, 0};
+ M m = M({1, 2, 3, 4, 5, 6, 7, 8}, {1, 2, 3, 4, 5, 6, 7, 8});
try {
g_counter = {first_throw, second_throw, 0};
- auto n = std::erase_if(m, ErasurePredicate());
+ auto n = std::erase_if(m, ErasurePredicate());
assert(n == 3);
// If it didn't throw at all, we're done.
- g_counter = {0,0,0};
- assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
- first_throw = 99; // "done"
+ g_counter = {0, 0, 0};
+ assert((m == M{{1, 1}, {2, 2}, {6, 6}, {7, 7}, {8, 8}}));
+ first_throw = 99; // "done"
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
- LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
break;
@@ -102,23 +99,23 @@ int main(int, char**)
using M = std::flat_map<int, ThrowingAssignment, ThrowingComparator>;
for (int first_throw = 1; first_throw < 99; ++first_throw) {
for (int second_throw = 1; second_throw < 99; ++second_throw) {
- g_counter = {0,0,0};
- M m = M({1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8});
+ g_counter = {0, 0, 0};
+ M m = M({1, 2, 3, 4, 5, 6, 7, 8}, {1, 2, 3, 4, 5, 6, 7, 8});
try {
g_counter = {first_throw, second_throw, 0};
- auto n = std::erase_if(m, ErasurePredicate());
+ auto n = std::erase_if(m, ErasurePredicate());
assert(n == 3);
// If it didn't throw at all, we're done.
- g_counter = {0,0,0};
- assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
- first_throw = 99; // "done"
+ g_counter = {0, 0, 0};
+ assert((m == M{{1, 1}, {2, 2}, {6, 6}, {7, 7}, {8, 8}}));
+ first_throw = 99; // "done"
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
- LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
break;
@@ -128,28 +125,29 @@ int main(int, char**)
}
}
{
- using M = std::flat_map<ThrowingAssignment, int, ThrowingComparator, std::deque<ThrowingAssignment>, std::deque<int>>;
+ using M =
+ std::flat_map<ThrowingAssignment, int, ThrowingComparator, std::deque<ThrowingAssignment>, std::deque<int>>;
for (int first_throw = 1; first_throw < 99; ++first_throw) {
for (int second_throw = 1; second_throw < 99; ++second_throw) {
- g_counter = {0,0,0};
- std::deque<ThrowingAssignment> container = {5,6,7,8};
- container.insert(container.begin(), {1,2,3,4});
- M m = M(std::move(container), {1,2,3,4,5,6,7,8});
+ g_counter = {0, 0, 0};
+ std::deque<ThrowingAssignment> container = {5, 6, 7, 8};
+ container.insert(container.begin(), {1, 2, 3, 4});
+ M m = M(std::move(container), {1, 2, 3, 4, 5, 6, 7, 8});
try {
g_counter = {first_throw, second_throw, 0};
- auto n = std::erase_if(m, ErasurePredicate());
+ auto n = std::erase_if(m, ErasurePredicate());
assert(n == 3);
// If it didn't throw at all, we're done.
- g_counter = {0,0,0};
- assert((m == M{{1,1}, {2,2}, {6,6}, {7,7}, {8,8}}));
- first_throw = 99; // "done"
+ g_counter = {0, 0, 0};
+ assert((m == M{{1, 1}, {2, 2}, {6, 6}, {7, 7}, {8, 8}}));
+ first_throw = 99; // "done"
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
+ assert(m.keys().size() == m.values().size()); // still sized correctly
+ assert(std::is_sorted(m.begin(), m.end())); // still sorted
assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
- LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected+8));
+ LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
break;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
index 68a40dd5b7f6dc..a96d0d8c1a95ba 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
@@ -26,7 +26,7 @@ struct A {
};
// Implement the operator< required in order to instantiate flat_map<A, X>
-bool operator<(A const& L, A const& R) { return L.data < R.data; }
+bool operator<(A const& L, A const& R) { return L.data < R.data; }
int main(int, char**) {
A a;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
index 513f72f11cc3f6..30843ee98297cd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
@@ -25,29 +25,28 @@
#include "test_iterators.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
- using P = std::pair<int, int>;
- using M = std::flat_map<int, int>;
- using It = forward_iterator<const P*>;
- M m = {{10,1}, {8,2}, {5,3}, {2,4}, {1,5}};
- P ar[] = {{3,1}, {1,2}, {4,3}, {1,4}, {5,5}, {9,6}};
- std::ranges::subrange r = { It(ar), It(ar + 6) };
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int>;
+ using It = forward_iterator<const P*>;
+ M m = {{10, 1}, {8, 2}, {5, 3}, {2, 4}, {1, 5}};
+ P ar[] = {{3, 1}, {1, 2}, {4, 3}, {1, 4}, {5, 5}, {9, 6}};
+ std::ranges::subrange r = {It(ar), It(ar + 6)};
static_assert(std::ranges::common_range<decltype(r)>);
m.insert_range(r);
- assert((m == M{{1,5}, {2,4}, {3,1}, {4,3}, {5,3}, {8,2}, {9,6}, {10,1}}));
+ assert((m == M{{1, 5}, {2, 4}, {3, 1}, {4, 3}, {5, 3}, {8, 2}, {9, 6}, {10, 1}}));
}
{
- using P = std::pair<int, int>;
- using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>>;
- using It = cpp20_input_iterator<const P*>;
- M m = {{8,1}, {5,2}, {3,3}, {2,4}};
- P ar[] = {{3,1}, {1,2}, {4,3}, {1,4}, {5,5}, {9,6}};
- std::ranges::subrange r = { It(ar), sentinel_wrapper<It>(It(ar + 6)) };
+ using P = std::pair<int, int>;
+ using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>>;
+ using It = cpp20_input_iterator<const P*>;
+ M m = {{8, 1}, {5, 2}, {3, 3}, {2, 4}};
+ P ar[] = {{3, 1}, {1, 2}, {4, 3}, {1, 4}, {5, 5}, {9, 6}};
+ std::ranges::subrange r = {It(ar), sentinel_wrapper<It>(It(ar + 6))};
static_assert(!std::ranges::common_range<decltype(r)>);
m.insert_range(r);
- assert((m == M{{1,2}, {2,4}, {3,3}, {4,3}, {5,2}, {8,1}, {9,6}}));
+ assert((m == M{{1, 2}, {2, 4}, {3, 3}, {4, 3}, {5, 2}, {8, 1}, {9, 6}}));
}
{
// The "uniquing" part uses the comparator, not operator==.
@@ -56,10 +55,10 @@ int main(int, char**)
};
using P = std::pair<int, int>;
using M = std::flat_map<int, int, ModTen>;
- M m = {{21,0}, {43,0}, {15,0}, {37,0}};
- P ar[] = {{33,1}, {18,1}, {55,1}, {18,1}, {42,1}};
+ M m = {{21, 0}, {43, 0}, {15, 0}, {37, 0}};
+ P ar[] = {{33, 1}, {18, 1}, {55, 1}, {18, 1}, {42, 1}};
m.insert_range(ar);
- assert((m == M{{21,0}, {42,1}, {43,0}, {15,0}, {37,0}, {18,1}}));
+ assert((m == M{{21, 0}, {42, 1}, {43, 0}, {15, 0}, {37, 0}, {18, 1}}));
}
{
// The "uniquing" part uses the comparator, not operator==.
@@ -68,26 +67,26 @@ int main(int, char**)
};
using P = std::pair<int, int>;
using M = std::flat_map<int, int, ModTen>;
- M m = {{21,0}, {43,0}, {15,0}, {37,0}};
- P ar[] = {{33,1}, {18,1}, {55,1}, {28,1}, {42,1}};
+ M m = {{21, 0}, {43, 0}, {15, 0}, {37, 0}};
+ P ar[] = {{33, 1}, {18, 1}, {55, 1}, {28, 1}, {42, 1}};
m.insert_range(ar);
- LIBCPP_ASSERT((m == M{{21,0}, {42,1}, {43,0}, {15,0}, {37,0}, {18,1}}));
+ LIBCPP_ASSERT((m == M{{21, 0}, {42, 1}, {43, 0}, {15, 0}, {37, 0}, {18, 1}}));
}
{
// Items are forwarded correctly from the input range (P2767).
- std::pair<MoveOnly, MoveOnly> a[] = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
+ std::pair<MoveOnly, MoveOnly> a[] = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
std::flat_map<MoveOnly, MoveOnly> m;
m.insert_range(a | std::views::as_rvalue);
- std::pair<MoveOnly, MoveOnly> expected[] = {{1,1}, {3,3}, {4,4}, {5,5}};
+ std::pair<MoveOnly, MoveOnly> expected[] = {{1, 1}, {3, 3}, {4, 4}, {5, 5}};
assert(std::ranges::equal(m, expected));
}
{
// The element type of the range doesn't need to be std::pair (P2767).
- std::pair<int, int> pa[] = {{3,3}, {1,1}, {4,4}, {1,1}, {5,5}};
- std::deque<std::reference_wrapper<std::pair<int, int>>> a(pa, pa+5);
+ std::pair<int, int> pa[] = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
+ std::deque<std::reference_wrapper<std::pair<int, int>>> a(pa, pa + 5);
std::flat_map<int, int> m;
m.insert_range(a);
- std::pair<int, int> expected[] = {{1,1}, {3,3}, {4,4}, {5,5}};
+ std::pair<int, int> expected[] = {{1, 1}, {3, 3}, {4, 4}, {5, 5}};
assert(std::ranges::equal(m, expected));
}
return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
index 426067105b76df..f30d2761fc0d69 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
@@ -31,14 +31,13 @@ struct Mod256 {
bool operator()(int x, int y) const { return (x % 256) < (y % 256); }
};
-int main(int, char**)
-{
+int main(int, char**) {
{
std::mt19937 randomness;
std::pair<uint16_t, uint16_t> pairs[400];
for (int i = 0; i < 400; ++i) {
uint16_t r = randomness();
- pairs[i] = {r, r};
+ pairs[i] = {r, r};
}
std::map<uint16_t, uint16_t, Mod256> m(pairs, pairs + 200);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
index 14fc0fab591684..ebbb6dfd8b7fee 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
@@ -24,7 +24,7 @@
#include "min_allocator.h"
static int expensive_comparisons = 0;
-static int cheap_comparisons = 0;
+static int cheap_comparisons = 0;
struct CompareCounter {
int i_ = 0;
@@ -40,18 +40,17 @@ struct CompareCounter {
}
};
-int main(int, char**)
-{
- const std::pair<int, int> expected[] = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}};
+int main(int, char**) {
+ const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
{
// insert(P&&)
// Unlike flat_set, here we can't use key_compare to compare value_type versus P,
// so we must eagerly convert to value_type.
- using M = std::flat_map<CompareCounter, int, std::less<>>;
- M m = {{1,1}, {2,2}, {4,4}, {5,5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3,3)); // conversion happens first
+ using M = std::flat_map<CompareCounter, int, std::less<>>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3, 3)); // conversion happens first
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
@@ -59,11 +58,11 @@ int main(int, char**)
}
{
// insert(const_iterator, P&&)
- using M = std::flat_map<CompareCounter, int, std::less<>>;
- M m = {{1,1}, {2,2}, {4,4}, {5,5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3,3));
+ using M = std::flat_map<CompareCounter, int, std::less<>>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(it == m.begin() + 2);
@@ -71,11 +70,11 @@ int main(int, char**)
}
{
// insert(value_type&&)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1,1}, {2,2}, {4,4}, {5,5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3,3)); // conversion happens last
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3, 3)); // conversion happens last
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
@@ -83,11 +82,11 @@ int main(int, char**)
}
{
// insert(const_iterator, value_type&&)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1,1}, {2,2}, {4,4}, {5,5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3,3));
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(it == m.begin() + 2);
@@ -95,11 +94,11 @@ int main(int, char**)
}
{
// emplace(Args&&...)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1,1}, {2,2}, {4,4}, {5,5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.emplace(std::make_pair(3,3)); // conversion happens first
+ using M = std::flat_map<CompareCounter, int>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<M::iterator, bool>> auto p = m.emplace(std::make_pair(3, 3)); // conversion happens first
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
index ddb68b11b20ee8..04117a690f46ae 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
@@ -23,10 +23,10 @@
void test() {
{
- using C = std::flat_map<int, char>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
+ using C = std::flat_map<int, char>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
using CRI = C::const_reverse_iterator;
static_assert(std::random_access_iterator<I>);
static_assert(std::random_access_iterator<CI>);
@@ -40,32 +40,32 @@ void test() {
static_assert(!std::indirectly_writable<CI, std::pair<int, char>>);
static_assert(!std::indirectly_writable<RI, std::pair<int, char>>);
static_assert(!std::indirectly_writable<CRI, std::pair<int, char>>);
- static_assert( std::sentinel_for<I, I>);
- static_assert( std::sentinel_for<I, CI>);
+ static_assert(std::sentinel_for<I, I>);
+ static_assert(std::sentinel_for<I, CI>);
static_assert(!std::sentinel_for<I, RI>);
static_assert(!std::sentinel_for<I, CRI>);
- static_assert( std::sentinel_for<CI, I>);
- static_assert( std::sentinel_for<CI, CI>);
+ static_assert(std::sentinel_for<CI, I>);
+ static_assert(std::sentinel_for<CI, CI>);
static_assert(!std::sentinel_for<CI, RI>);
static_assert(!std::sentinel_for<CI, CRI>);
static_assert(!std::sentinel_for<RI, I>);
static_assert(!std::sentinel_for<RI, CI>);
- static_assert( std::sentinel_for<RI, RI>);
- static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(std::sentinel_for<RI, RI>);
+ static_assert(std::sentinel_for<RI, CRI>);
static_assert(!std::sentinel_for<CRI, I>);
static_assert(!std::sentinel_for<CRI, CI>);
- static_assert( std::sentinel_for<CRI, RI>);
- static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::sentinel_for<CRI, RI>);
+ static_assert(std::sentinel_for<CRI, CRI>);
static_assert(std::indirectly_movable_storable<I, std::pair<int, char>*>);
static_assert(std::indirectly_movable_storable<CI, std::pair<int, char>*>);
static_assert(std::indirectly_movable_storable<RI, std::pair<int, char>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<int, char>*>);
}
{
- using C = std::flat_map<char*, int, std::less<>, std::deque<char*>, std::vector<int>>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
+ using C = std::flat_map<char*, int, std::less<>, std::deque<char*>, std::vector<int>>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
using CRI = C::const_reverse_iterator;
static_assert(std::random_access_iterator<I>);
static_assert(std::random_access_iterator<CI>);
@@ -79,32 +79,32 @@ void test() {
static_assert(!std::indirectly_writable<CI, std::pair<char*, int>>);
static_assert(!std::indirectly_writable<RI, std::pair<char*, int>>);
static_assert(!std::indirectly_writable<CRI, std::pair<char*, int>>);
- static_assert( std::sentinel_for<I, I>);
- static_assert( std::sentinel_for<I, CI>);
+ static_assert(std::sentinel_for<I, I>);
+ static_assert(std::sentinel_for<I, CI>);
static_assert(!std::sentinel_for<I, RI>);
static_assert(!std::sentinel_for<I, CRI>);
- static_assert( std::sentinel_for<CI, I>);
- static_assert( std::sentinel_for<CI, CI>);
+ static_assert(std::sentinel_for<CI, I>);
+ static_assert(std::sentinel_for<CI, CI>);
static_assert(!std::sentinel_for<CI, RI>);
static_assert(!std::sentinel_for<CI, CRI>);
static_assert(!std::sentinel_for<RI, I>);
static_assert(!std::sentinel_for<RI, CI>);
- static_assert( std::sentinel_for<RI, RI>);
- static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(std::sentinel_for<RI, RI>);
+ static_assert(std::sentinel_for<RI, CRI>);
static_assert(!std::sentinel_for<CRI, I>);
static_assert(!std::sentinel_for<CRI, CI>);
- static_assert( std::sentinel_for<CRI, RI>);
- static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::sentinel_for<CRI, RI>);
+ static_assert(std::sentinel_for<CRI, CRI>);
static_assert(std::indirectly_movable_storable<I, std::pair<char*, int>*>);
static_assert(std::indirectly_movable_storable<CI, std::pair<char*, int>*>);
static_assert(std::indirectly_movable_storable<RI, std::pair<char*, int>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<char*, int>*>);
}
{
- using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
+ using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
using CRI = C::const_reverse_iterator;
static_assert(std::random_access_iterator<I>);
static_assert(std::random_access_iterator<CI>);
@@ -118,22 +118,22 @@ void test() {
static_assert(!std::indirectly_writable<CI, std::pair<char, bool>>);
static_assert(!std::indirectly_writable<RI, std::pair<char, bool>>);
static_assert(!std::indirectly_writable<CRI, std::pair<char, bool>>);
- static_assert( std::sentinel_for<I, I>);
- static_assert( std::sentinel_for<I, CI>);
+ static_assert(std::sentinel_for<I, I>);
+ static_assert(std::sentinel_for<I, CI>);
static_assert(!std::sentinel_for<I, RI>);
static_assert(!std::sentinel_for<I, CRI>);
- static_assert( std::sentinel_for<CI, I>);
- static_assert( std::sentinel_for<CI, CI>);
+ static_assert(std::sentinel_for<CI, I>);
+ static_assert(std::sentinel_for<CI, CI>);
static_assert(!std::sentinel_for<CI, RI>);
static_assert(!std::sentinel_for<CI, CRI>);
static_assert(!std::sentinel_for<RI, I>);
static_assert(!std::sentinel_for<RI, CI>);
- static_assert( std::sentinel_for<RI, RI>);
- static_assert( std::sentinel_for<RI, CRI>);
+ static_assert(std::sentinel_for<RI, RI>);
+ static_assert(std::sentinel_for<RI, CRI>);
static_assert(!std::sentinel_for<CRI, I>);
static_assert(!std::sentinel_for<CRI, CI>);
- static_assert( std::sentinel_for<CRI, RI>);
- static_assert( std::sentinel_for<CRI, CRI>);
+ static_assert(std::sentinel_for<CRI, RI>);
+ static_assert(std::sentinel_for<CRI, CRI>);
static_assert(std::indirectly_movable_storable<I, std::pair<char, bool>*>);
static_assert(std::indirectly_movable_storable<CI, std::pair<char, bool>*>);
static_assert(std::indirectly_movable_storable<RI, std::pair<char, bool>*>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
index 8094e7771fc604..1e697a1c02ed5b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
@@ -22,11 +22,10 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, char>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
assert(m.lower_bound(0) == m.begin());
@@ -41,8 +40,13 @@ int main(int, char**)
assert(std::as_const(m).lower_bound(9) == m.end());
}
{
- using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ using M =
+ std::flat_map<int,
+ char,
+ std::greater<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<char, min_allocator<char>>>;
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
assert(m.lower_bound(0) == m.end());
@@ -58,15 +62,15 @@ int main(int, char**)
}
{
using M = std::flat_map<bool, bool>;
- M m = {{true,false}, {false,true}};
+ M m = {{true, false}, {false, true}};
ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
assert(m.lower_bound(true) == m.begin() + 1);
assert(m.lower_bound(false) == m.begin());
- m = {{true,true}};
+ m = {{true, true}};
assert(m.lower_bound(true) == m.begin());
assert(m.lower_bound(false) == m.begin());
- m = {{false,false}};
+ m = {{false, false}};
assert(std::as_const(m).lower_bound(true) == m.end());
assert(std::as_const(m).lower_bound(false) == m.begin());
m.clear();
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
index 1c21704ebd64c1..3f464c65d43a84 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
@@ -22,12 +22,11 @@
#include "test_allocator.h"
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using A1 = limited_allocator<int, 10>;
using A2 = limited_allocator<int, 20>;
- using C = std::flat_map<int, int, std::less<int>, std::vector<int, A1>, std::vector<int, A2>>;
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int, A1>, std::vector<int, A2>>;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
C c;
@@ -39,7 +38,7 @@ int main(int, char**)
{
using A1 = limited_allocator<int, 10>;
using A2 = limited_allocator<int, 20>;
- using C = std::flat_map<int, int, std::less<int>, std::vector<int, A2>, std::vector<int, A1>>;
+ using C = std::flat_map<int, int, std::less<int>, std::vector<int, A2>, std::vector<int, A1>>;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
C c;
@@ -53,8 +52,7 @@ int main(int, char**)
using C = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::vector<int, A>>;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
- const C::size_type max_dist =
- static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
+ const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
@@ -65,8 +63,7 @@ int main(int, char**)
typedef std::flat_map<char, char> C;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
- const C::size_type max_dist =
- static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
+ const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
index 123dac1cc18f42..6782b4c0c50db9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/op_compare.pass.cpp
@@ -28,53 +28,53 @@
int main(int, char**) {
{
using C = std::flat_map<int, int>;
- C s1 = {{1,1}};
- C s2 = {{2,0}}; // {{1,1}} versus {{2,0}}
+ C s1 = {{1, 1}};
+ C s2 = {{2, 0}}; // {{1,1}} versus {{2,0}}
ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering);
AssertComparisonsReturnBool<C>();
assert(testComparisons(s1, s2, false, true));
- s2 = {{1,1}}; // {{1,1}} versus {{1,1}}
+ s2 = {{1, 1}}; // {{1,1}} versus {{1,1}}
assert(testComparisons(s1, s2, true, false));
- s2 = {{1,1},{2,0}}; // {{1,1}} versus {{1,1},{2,0}}
+ s2 = {{1, 1}, {2, 0}}; // {{1,1}} versus {{1,1},{2,0}}
assert(testComparisons(s1, s2, false, true));
- s1 = {{0,0},{1,1},{2,2}}; // {{0,0},{1,1},{2,2}} versus {{1,1},{2,0}}
+ s1 = {{0, 0}, {1, 1}, {2, 2}}; // {{0,0},{1,1},{2,2}} versus {{1,1},{2,0}}
assert(testComparisons(s1, s2, false, true));
- s2 = {{0,0},{1,1},{2,3}}; // {{0,0},{1,1},{2,2}} versus {{0,0},{1,1},{2,3}}
+ s2 = {{0, 0}, {1, 1}, {2, 3}}; // {{0,0},{1,1},{2,2}} versus {{0,0},{1,1},{2,3}}
assert(testComparisons(s1, s2, false, true));
}
{
// Comparisons use value_type's native operators, not the comparator
using C = std::flat_map<int, int, std::greater<int>>;
- C s1 = {{1,1}};
- C s2 = {{2,0}}; // {{1,1}} versus {{2,0}}
+ C s1 = {{1, 1}};
+ C s2 = {{2, 0}}; // {{1,1}} versus {{2,0}}
ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering);
AssertComparisonsReturnBool<C>();
assert(testComparisons(s1, s2, false, true));
- s2 = {{1,1}}; // {{1,1}} versus {{1,1}}
+ s2 = {{1, 1}}; // {{1,1}} versus {{1,1}}
assert(testComparisons(s1, s2, true, false));
- s2 = {{1,1},{2,0}}; // {{1,1}} versus {{2,0},{1,1}}
+ s2 = {{1, 1}, {2, 0}}; // {{1,1}} versus {{2,0},{1,1}}
assert(testComparisons(s1, s2, false, true));
- s1 = {{0,0},{1,1},{2,2}}; // {{2,2},{1,1},{0,0}} versus {2,0},{1,1}}
+ s1 = {{0, 0}, {1, 1}, {2, 2}}; // {{2,2},{1,1},{0,0}} versus {2,0},{1,1}}
assert(testComparisons(s1, s2, false, false));
- s2 = {{0,0},{1,1},{2,3}}; // {{2,2},{1,1},{0,0}} versus {{2,3},{1,1},{0,0}}
+ s2 = {{0, 0}, {1, 1}, {2, 3}}; // {{2,2},{1,1},{0,0}} versus {{2,3},{1,1},{0,0}}
assert(testComparisons(s1, s2, false, true));
}
{
using C = std::flat_map<double, int>;
- C s1 = { {1, 1} };
- C s2 = C(std::sorted_unique, { {std::numeric_limits<double>::quiet_NaN(), 2} });
+ C s1 = {{1, 1}};
+ C s2 = C(std::sorted_unique, {{std::numeric_limits<double>::quiet_NaN(), 2}});
ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
AssertComparisonsReturnBool<C>();
assert(testComparisonsComplete(s1, s2, false, false, false));
}
{
using C = std::flat_map<int, double>;
- C s1 = { {1, 1} };
- C s2 = C(std::sorted_unique, { {2, std::numeric_limits<double>::quiet_NaN()} });
+ C s1 = {{1, 1}};
+ C s2 = C(std::sorted_unique, {{2, std::numeric_limits<double>::quiet_NaN()}});
ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
AssertComparisonsReturnBool<C>();
assert(testComparisonsComplete(s1, s2, false, true, false));
- s2 = C(std::sorted_unique, { {1, std::numeric_limits<double>::quiet_NaN()} });
+ s2 = C(std::sorted_unique, {{1, std::numeric_limits<double>::quiet_NaN()}});
assert(testComparisonsComplete(s1, s2, false, false, false));
}
{
@@ -83,14 +83,16 @@ int main(int, char**) {
bool operator()(double a, double b) const { return std::strong_order(a, b) < 0; }
};
using C = std::flat_map<double, double, StrongComp>;
- C s1 = {{1, 1}};
- C s2 = { {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()} };
+ C s1 = {{1, 1}};
+ C s2 = {{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}};
ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering);
AssertComparisonsReturnBool<C>();
assert(testComparisonsComplete(s1, s2, false, false, false));
- s1 = { { {1, 1}, {std::numeric_limits<double>::quiet_NaN(), 1} } };
- s2 = { { {std::numeric_limits<double>::quiet_NaN(), 1}, {1, 1} } };
- assert(std::lexicographical_compare_three_way(s1.keys().begin(), s1.keys().end(), s2.keys().begin(), s2.keys().end(), std::strong_order) == std::strong_ordering::equal);
+ s1 = {{{1, 1}, {std::numeric_limits<double>::quiet_NaN(), 1}}};
+ s2 = {{{std::numeric_limits<double>::quiet_NaN(), 1}, {1, 1}}};
+ assert(std::lexicographical_compare_three_way(
+ s1.keys().begin(), s1.keys().end(), s2.keys().begin(), s2.keys().end(), std::strong_order) ==
+ std::strong_ordering::equal);
assert(s1 != s2);
assert((s1 <=> s2) == std::partial_ordering::unordered);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
index d3aba8b14172e0..02d2d799db713a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
@@ -39,8 +39,7 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using C = std::flat_map<int, short>;
static_assert(std::is_same_v<C::key_type, int>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
index 76238c16b1129e..4058bdd4b6f3d3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
@@ -22,11 +22,10 @@
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**)
-{
+int main(int, char**) {
{
using M = std::flat_map<int, char>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
assert(m.upper_bound(0) == m.begin());
@@ -41,8 +40,13 @@ int main(int, char**)
assert(std::as_const(m).upper_bound(9) == m.end());
}
{
- using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<char, min_allocator<char>>>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
+ using M =
+ std::flat_map<int,
+ char,
+ std::greater<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<char, min_allocator<char>>>;
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
assert(m.upper_bound(0) == m.end());
@@ -58,15 +62,15 @@ int main(int, char**)
}
{
using M = std::flat_map<bool, bool>;
- M m = {{true,false}, {false,true}};
+ M m = {{true, false}, {false, true}};
ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
assert(m.upper_bound(true) == m.end());
assert(m.upper_bound(false) == m.begin() + 1);
- m = {{true,true}};
+ m = {{true, true}};
assert(m.upper_bound(true) == m.end());
assert(m.upper_bound(false) == m.begin());
- m = {{false,false}};
+ m = {{false, false}};
assert(std::as_const(m).upper_bound(true) == m.end());
assert(std::as_const(m).upper_bound(false) == m.end());
m.clear();
>From 9a6689c3cb06f05e8529abf11bcc60c6b996a84a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Wed, 21 Aug 2024 10:43:24 +0100
Subject: [PATCH 05/40] fix some comments
---
libcxx/include/__flat_map/flat_map.h | 28 +++++++++++++++-------------
1 file changed, 15 insertions(+), 13 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index de08cf6a0a1814..540ab0984e6c55 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -6,6 +6,7 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
+
#ifndef _LIBCPP___FLAT_MAP_FLAT_MAP_H
#define _LIBCPP___FLAT_MAP_FLAT_MAP_H
@@ -742,14 +743,14 @@ class flat_map {
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (const exception& __ex) {
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
std::string("flat_map::erase: "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent. Reason: ") +
__ex.what());
} catch (...) {
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
"flat_map::erase: "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent.");
@@ -1050,9 +1051,9 @@ class flat_map {
}
template <class _Container>
- static consteval bool __failed_emplacement_has_side_effects() {
+ static consteval bool __emplacement_has_strong_exception_safety_guarantee() {
// [container.reqmts] If an exception is thrown by an insert() or emplace() function while inserting a single
- // element, that function has no effects. Except that there is exceptional cases...
+ // element, that function has no effects. Except it is specified otherwise in the container...
// according to http://eel.is/c++draft/deque.modifiers#3 and http://eel.is/c++draft/vector.modifiers#2,
// the only exceptions that can cause side effects on single emplacement are by move constructors of
@@ -1070,26 +1071,27 @@ class flat_map {
}
}
- struct flat_map_restore_error : runtime_error {
+ struct __flat_map_restore_error : runtime_error {
using runtime_error::runtime_error;
};
template <class _Container, class _Iter, class... _Args>
_LIBCPP_HIDE_FROM_ABI ranges::iterator_t<_Container>
__safe_emplace(_Container& __container, _Iter&& __iter, _Args&&... __args) {
- if constexpr (!__failed_emplacement_has_side_effects<_Container>()) {
+ if constexpr (__emplacement_has_strong_exception_safety_guarantee<_Container>()) {
// just let the exception be thrown as the container is still in its original state on exception
return __container.emplace(__iter, std::forward<_Args>(__args)...);
} else {
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ return __container.emplace(__iter, std::forward<_Args>(__args)...);
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (const exception& __ex) {
// The container might be in some unknown state and we can't get flat_map into consistent state
// because we have two containers. The only possible solution is to clear them out
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
std::string("flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent. Reason: ") +
@@ -1098,7 +1100,7 @@ class flat_map {
// The container might be in some unknown state and we can't get flat_map into consistent state
// because we have two containers. The only possible solution is to clear them out
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
"flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent.");
@@ -1124,7 +1126,7 @@ class flat_map {
// The container might be in some unknown state and we can't get flat_map into consistent state
// because we have two containers. The only possible solution is to clear them out
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
std::string("flat_map: Erasing on the underlying container has failed. "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent. Reason: ") +
@@ -1133,7 +1135,7 @@ class flat_map {
// The container might be in some unknown state and we can't get flat_map into consistent state
// because we have two containers. The only possible solution is to clear them out
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
"flat_map: Erasing on the underlying container has failed. "
"Unable to restore flat_map to previous state. Clear out the containers to make the two "
"containers consistent.");
@@ -1152,7 +1154,7 @@ class flat_map {
auto __mapped_it = __safe_emplace(__containers_.values, __it_mapped, std::forward<_MArgs>(__mapped_args)...);
return iterator(std::move(__key_it), std::move(__mapped_it));
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const flat_map_restore_error&) {
+ } catch (const __flat_map_restore_error&) {
// both containers already cleared out
throw;
} catch (...) {
@@ -1190,13 +1192,13 @@ class flat_map {
auto __mapped_iter = __safe_erase(__containers_.values, __m_iter);
return iterator(std::move(__key_iter), std::move(__mapped_iter));
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const flat_map_restore_error&) {
+ } catch (const __flat_map_restore_error&) {
// both containers already cleared out
throw;
} catch (...) {
// If the second erase throws, the first erase already happened. The flat_map is inconsistent.
clear();
- throw flat_map_restore_error(
+ throw __flat_map_restore_error(
"flat_map::erase: Key has been erased but exception thrown on erasing mapped value. To make flat_map in "
"consistent state, clear out the flat_map");
}
>From 5b2f3b2171c1b485ba83917e5727bee8e2e40ca7 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 31 Aug 2024 21:01:39 +0100
Subject: [PATCH 06/40] fix some comments
---
libcxx/include/CMakeLists.txt | 1 +
libcxx/include/__flat_map/container_traits.h | 46 ++++
libcxx/include/__flat_map/flat_map.h | 245 +++++--------------
libcxx/include/deque | 1 +
libcxx/include/flat_map | 20 +-
libcxx/include/forward_list | 1 +
libcxx/include/list | 1 +
7 files changed, 113 insertions(+), 202 deletions(-)
create mode 100644 libcxx/include/__flat_map/container_traits.h
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index c59a63e69facf0..f73b39174ef4c2 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -358,6 +358,7 @@ set(files
__filesystem/recursive_directory_iterator.h
__filesystem/space_info.h
__filesystem/u8path.h
+ __flat_map/container_traits.h
__flat_map/flat_map.h
__flat_map/sorted_unique.h
__format/buffer.h
diff --git a/libcxx/include/__flat_map/container_traits.h b/libcxx/include/__flat_map/container_traits.h
new file mode 100644
index 00000000000000..703c7ef430f5a9
--- /dev/null
+++ b/libcxx/include/__flat_map/container_traits.h
@@ -0,0 +1,46 @@
+// -*- 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_MAP_CONTAINER_TRAITS_H
+#define _LIBCPP___FLAT_MAP_CONTAINER_TRAITS_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+inline constexpr bool __is_stl_container = false;
+
+template <class _Tp>
+struct __container_traits {
+ static constexpr bool __emplacement_has_strong_exception_safety_guarantee = false;
+};
+
+template <class _Tp>
+ requires __is_stl_container<_Tp>
+struct __container_traits<_Tp> {
+ // http://eel.is/c++draft/container.reqmts
+ // 66 Unless otherwise specified (see [associative.reqmts.except], [unord.req.except], [deque.modifiers],
+ // [inplace.vector.modifiers], and [vector.modifiers]) all container types defined in this Clause meet the following
+ // additional requirements:
+ // - (66.1) If an exception is thrown by an insert() or emplace() function while inserting a single element, that
+ // function has no effects.
+ static constexpr bool __emplacement_has_strong_exception_safety_guarantee = true;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___FLAT_MAP_CONTAINER_TRAITS_H
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 540ab0984e6c55..0dba06cc5e87b7 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -20,6 +20,7 @@
#include <__compare/synth_three_way.h>
#include <__concepts/convertible_to.h>
#include <__config>
+#include <__flat_map/container_traits.h>
#include <__flat_map/sorted_unique.h>
#include <__functional/invoke.h>
#include <__functional/is_transparent.h>
@@ -604,30 +605,17 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI containers extract() && {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- return std::move(__containers_);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (...) {
- clear();
- throw;
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ auto __ret = std::move(__containers_);
+ __guard.__complete();
+ return __ret;
}
_LIBCPP_HIDE_FROM_ABI void replace(key_container_type&& __key_cont, mapped_container_type&& __mapped_cont) {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- __containers_.keys = std::move(__key_cont);
- __containers_.values = std::move(__mapped_cont);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (...) {
- clear();
- throw;
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ __containers_.keys = std::move(__key_cont);
+ __containers_.values = std::move(__mapped_cont);
+ __guard.__complete();
}
template <class... _Args>
@@ -734,44 +722,23 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- auto __key_it = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_);
- auto __mapped_it = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_);
- return iterator(std::move(__key_it), std::move(__mapped_it));
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const exception& __ex) {
- clear();
- throw __flat_map_restore_error(
- std::string("flat_map::erase: "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent. Reason: ") +
- __ex.what());
- } catch (...) {
- clear();
- throw __flat_map_restore_error(
- "flat_map::erase: "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent.");
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ auto __key_it = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_);
+ auto __mapped_it = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_);
+ __on_failure.__complete();
+ return iterator(std::move(__key_it), std::move(__mapped_it));
}
_LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- using std::swap;
- swap(__compare_, __y.__compare_);
- swap(__containers_.keys, __y.__containers_.keys);
- swap(__containers_.values, __y.__containers_.values);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (...) {
- clear();
- __y.clear();
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ auto __guard = std::__make_exception_guard([&]() noexcept {
+ clear() /* noexcept */;
+ __y.clear(); /*noexcept*/
+ });
+ using std::swap;
+ swap(__compare_, __y.__compare_);
+ swap(__containers_.keys, __y.__containers_.keys);
+ swap(__containers_.values, __y.__containers_.values);
+ __guard.__complete();
}
_LIBCPP_HIDE_FROM_ABI void clear() noexcept {
@@ -1050,118 +1017,43 @@ class flat_map {
}
}
- template <class _Container>
- static consteval bool __emplacement_has_strong_exception_safety_guarantee() {
- // [container.reqmts] If an exception is thrown by an insert() or emplace() function while inserting a single
- // element, that function has no effects. Except it is specified otherwise in the container...
-
- // according to http://eel.is/c++draft/deque.modifiers#3 and http://eel.is/c++draft/vector.modifiers#2,
- // the only exceptions that can cause side effects on single emplacement are by move constructors of
- // non-Cpp17CopyInsertable T
-
- using _Element = typename _Container::value_type;
- if constexpr (is_nothrow_move_constructible_v<_Element>) {
- return false;
- } else {
- if constexpr (requires { typename _Container::allocator_type; }) {
- return !__is_cpp17_copy_insertable<typename _Container::allocator_type>::value;
+ template <class _IterK, class _IterM, class _KeyArg, class... _MArgs>
+ _LIBCPP_HIDE_FROM_ABI iterator
+ __try_emplace_impl(_IterK&& __it_key, _IterM&& __it_mapped, _KeyArg&& __key, _MArgs&&... __mapped_args) {
+ auto __on_key_failed = std::__make_exception_guard([&]() noexcept {
+ if constexpr (__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) {
+ // Nothing to roll back!
} else {
- return !__is_cpp17_copy_insertable<std::allocator<_Element>>::value;
+ // we need to clear both because we don't know the state of our keys anymore
+ clear() /* noexcept */;
}
- }
- }
-
- struct __flat_map_restore_error : runtime_error {
- using runtime_error::runtime_error;
- };
-
- template <class _Container, class _Iter, class... _Args>
- _LIBCPP_HIDE_FROM_ABI ranges::iterator_t<_Container>
- __safe_emplace(_Container& __container, _Iter&& __iter, _Args&&... __args) {
- if constexpr (__emplacement_has_strong_exception_safety_guarantee<_Container>()) {
- // just let the exception be thrown as the container is still in its original state on exception
- return __container.emplace(__iter, std::forward<_Args>(__args)...);
- } else {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- return __container.emplace(__iter, std::forward<_Args>(__args)...);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const exception& __ex) {
- // The container might be in some unknown state and we can't get flat_map into consistent state
- // because we have two containers. The only possible solution is to clear them out
- clear();
- throw __flat_map_restore_error(
- std::string("flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent. Reason: ") +
- __ex.what());
- } catch (...) {
- // The container might be in some unknown state and we can't get flat_map into consistent state
- // because we have two containers. The only possible solution is to clear them out
- clear();
- throw __flat_map_restore_error(
- "flat_map::emplace: Emplacement on the underlying container has failed and has side effect. "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent.");
+ });
+ auto __key_it = __containers_.keys.emplace(__it_key, std::forward<_KeyArg>(__key));
+ __on_key_failed.__complete();
+
+ auto __on_value_failed = std::__make_exception_guard([&]() noexcept {
+ if constexpr (!__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) {
+ // we need to clear both because we don't know the state of our values anymore
+ clear() /* noexcept */;
+ } else {
+ // In this case, we know the values are just like before we attempted emplacement,
+ // and we also know that the keys have been emplaced successfully. Just roll back the keys.
+ try {
+ __containers_.keys.erase(__key_it);
+ } catch (...) {
+ // Now things are funky for real. We're failing to rollback the keys.
+ // Just give up and clear the whole thing.
+ //
+ // Also, swallow the exception that happened during the rollback and let the
+ // original value-emplacement exception propagate normally.
+ clear() /* noexcept */;
+ }
}
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- }
- }
-
- template <class _Container, class _Iter>
- _LIBCPP_HIDE_FROM_ABI auto __safe_erase(_Container& __container, _Iter&& __iter) {
- // [container.reqmts] No erase(), clear(), pop_back() or pop_front() function throws an exception,
- // except that there are exceptional cases
-
- // http://eel.is/c++draft/deque.modifiers#5
- // http://eel.is/c++draft/vector.modifiers#4
-
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- return __container.erase(__iter);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const exception& __ex) {
- // The container might be in some unknown state and we can't get flat_map into consistent state
- // because we have two containers. The only possible solution is to clear them out
- clear();
- throw __flat_map_restore_error(
- std::string("flat_map: Erasing on the underlying container has failed. "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent. Reason: ") +
- __ex.what());
- } catch (...) {
- // The container might be in some unknown state and we can't get flat_map into consistent state
- // because we have two containers. The only possible solution is to clear them out
- clear();
- throw __flat_map_restore_error(
- "flat_map: Erasing on the underlying container has failed. "
- "Unable to restore flat_map to previous state. Clear out the containers to make the two "
- "containers consistent.");
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- }
+ });
+ auto __mapped_it = __containers_.values.emplace(__it_mapped, std::forward<_MArgs>(__mapped_args)...);
+ __on_value_failed.__complete();
- template <class _IterK, class _IterM, class _KeyArg, class... _MArgs>
- _LIBCPP_HIDE_FROM_ABI iterator
- __try_emplace_impl(_IterK&& __it_key, _IterM&& __it_mapped, _KeyArg&& __key, _MArgs&&... __mapped_args) {
- auto __key_it = __safe_emplace(__containers_.keys, __it_key, std::forward<_KeyArg>(__key));
-
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- auto __mapped_it = __safe_emplace(__containers_.values, __it_mapped, std::forward<_MArgs>(__mapped_args)...);
- return iterator(std::move(__key_it), std::move(__mapped_it));
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const __flat_map_restore_error&) {
- // both containers already cleared out
- throw;
- } catch (...) {
- // If the second emplace throws and it has no effects on `values`, we need to erase the emplaced key.
- __safe_erase(__containers_.keys, __key_it);
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ return iterator(std::move(__key_it), std::move(__mapped_it));
}
template <class _Kp, class _Mapped, class... _Hint>
@@ -1184,25 +1076,12 @@ class flat_map {
}
template <class _KIter, class _MIter>
- _LIBCPP_HIDE_FROM_ABI iterator __erase_impl(_KIter __k_iter, _MIter __m_iter) {
- auto __key_iter = __safe_erase(__containers_.keys, __k_iter);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
- auto __mapped_iter = __safe_erase(__containers_.values, __m_iter);
- return iterator(std::move(__key_iter), std::move(__mapped_iter));
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (const __flat_map_restore_error&) {
- // both containers already cleared out
- throw;
- } catch (...) {
- // If the second erase throws, the first erase already happened. The flat_map is inconsistent.
- clear();
- throw __flat_map_restore_error(
- "flat_map::erase: Key has been erased but exception thrown on erasing mapped value. To make flat_map in "
- "consistent state, clear out the flat_map");
- }
-# endif // _LIBCPP_HAS_NO_EXCEPTIONS
+ _LIBCPP_HIDE_FROM_ABI iterator __erase_impl(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) {
+ auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ auto __key_iter = __containers_.keys.erase(__key_iter_to_remove);
+ auto __mapped_iter = __containers_.values.erase(__mapped_iter_to_remove);
+ __on_failure.__complete();
+ return iterator(std::move(__key_iter), std::move(__mapped_iter));
}
template <class _Key2, class _Tp2, class _Compare2, class _KeyContainer2, class _MappedContainer2, class _Predicate>
diff --git a/libcxx/include/deque b/libcxx/include/deque
index 11219d1a99244e..4e06bcb9c0bdfd 100644
--- a/libcxx/include/deque
+++ b/libcxx/include/deque
@@ -194,6 +194,7 @@ template <class T, class Allocator, class Predicate>
#include <__assert>
#include <__config>
#include <__debug_utils/sanitizers.h>
+#include <__flat_map/container_traits.h>
#include <__format/enable_insertable.h>
#include <__fwd/deque.h>
#include <__iterator/distance.h>
diff --git a/libcxx/include/flat_map b/libcxx/include/flat_map
index 7abda6ae5819d2..29a2dc4ed95421 100644
--- a/libcxx/include/flat_map
+++ b/libcxx/include/flat_map
@@ -34,29 +34,11 @@ namespace std {
class Predicate>
typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
-
- // [flat.multimap], class template flat_multimap
- template<class Key, class T, class Compare = less<Key>,
- class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
- class flat_multimap;
-
- struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
- inline constexpr sorted_equivalent_t sorted_equivalent{};
-
- template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
- class Allocator>
- struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
- Allocator>;
-
- // [flat.multimap.erasure], erasure for flat_multimap
- template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
- class Predicate>
- typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
- erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
*/
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
+#include <__flat_map/container_traits.h>
#include <__flat_map/flat_map.h>
#include <__flat_map/sorted_unique.h>
#include <version>
diff --git a/libcxx/include/forward_list b/libcxx/include/forward_list
index 04466d9a673fc6..6f16a9861a390c 100644
--- a/libcxx/include/forward_list
+++ b/libcxx/include/forward_list
@@ -200,6 +200,7 @@ template <class T, class Allocator, class Predicate>
#include <__algorithm/lexicographical_compare_three_way.h>
#include <__algorithm/min.h>
#include <__config>
+#include <__flat_map/container_traits.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/move_iterator.h>
diff --git a/libcxx/include/list b/libcxx/include/list
index 95302754271226..336883895a166a 100644
--- a/libcxx/include/list
+++ b/libcxx/include/list
@@ -204,6 +204,7 @@ template <class T, class Allocator, class Predicate>
#include <__algorithm/min.h>
#include <__assert>
#include <__config>
+#include <__flat_map/container_traits.h>
#include <__format/enable_insertable.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
>From 7c9e529c6b6b62a3a3058cfbeb520105db7d208a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 1 Sep 2024 20:04:49 +0100
Subject: [PATCH 07/40] fix some comments
---
libcxx/include/__flat_map/flat_map.h | 34 +++++++++++++++++++
.../move_assign_noexcept.pass.cpp | 5 +++
.../flat.map.cons/move_noexcept.pass.cpp | 7 +++-
3 files changed, 45 insertions(+), 1 deletion(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 0dba06cc5e87b7..b0a72ba63d69de 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -234,6 +234,25 @@ class flat_map {
is_nothrow_default_constructible_v<_Compare>)
: __containers_(), __compare_() {}
+ // copy/move constructors are not specified in the spec (defaulted)
+ // but move constructor can potentially leave moved from object in an inconsistent
+ // state if an exception is thrown
+ _LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
+
+# if defined(_LIBCPP_HAS_NO_EXCEPTIONS)
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&&) = default;
+# else // defined(_LIBCPP_HAS_NO_EXCEPTIONS)
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
+ is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
+ is_nothrow_move_constructible_v<_Compare>) try
+ : __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
+ } catch (...) {
+ __other.clear();
+ throw;
+ }
+
+# endif // defined(_LIBCPP_HAS_NO_EXCEPTIONS)
+
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map& __other, const _Allocator& __alloc)
@@ -420,6 +439,21 @@ class flat_map {
return *this;
}
+ // copy/move assignment are not specified in the spec (defaulted)
+ // but move assignment can potentially leave moved from object in an inconsistent
+ // state if an exception is thrown
+ _LIBCPP_HIDE_FROM_ABI flat_map& operator=(const flat_map&) = default;
+
+ _LIBCPP_HIDE_FROM_ABI flat_map& operator=(flat_map&& __other) noexcept(
+ is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_MappedContainer> &&
+ is_nothrow_move_assignable_v<_Compare>) {
+ auto __guard = std::__make_exception_guard([&]() noexcept { __other.clear() /* noexcept */; });
+ __containers_ = std::move(__other.__containers_);
+ __compare_ = std::move(__other.__compare_);
+ __guard.__complete();
+ return *this;
+ }
+
// iterators
_LIBCPP_HIDE_FROM_ABI iterator begin() noexcept {
return iterator(__containers_.keys.begin(), __containers_.values.begin());
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
index 763dcd051c104a..b223fca99eb275 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
@@ -82,11 +82,14 @@ int main(int, char**) {
std::vector<MoveOnly, other_allocator<MoveOnly>>>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
}
+ /*
+ why? std::function move assignment is noexcept
{
// Test with a comparator that throws on copy-assignment.
using C = std::flat_map<int, int, std::function<bool(int, int)>>;
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v<C>);
}
+ */
{
// Test with a container that throws on move-assignment.
using C = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::vector<int>>;
@@ -97,6 +100,7 @@ int main(int, char**) {
using C = std::flat_map<int, int, std::less<int>, std::vector<int>, std::pmr::vector<int>>;
static_assert(!std::is_nothrow_move_assignable_v<C>);
}
+ /* why?
{
// Moving the flat_map copies the comparator (to support std::function comparators)
using C = std::flat_map<int, int, MoveSensitiveComp>;
@@ -108,5 +112,6 @@ int main(int, char**) {
LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
assert(!d.key_comp().is_moved_from_);
}
+ */
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
index c170f0fd758274..e3a6c944c8d5fd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
@@ -94,10 +94,14 @@ int main(int, char**) {
{
// Comparator fails to be nothrow-copy-constructible
using C = std::flat_map<int, int, ThrowingCopyComp>;
- static_assert(!std::is_nothrow_move_constructible_v<C>);
+ //todo: why???
+ //static_assert(!std::is_nothrow_move_constructible_v<C>);
+ static_assert(std::is_nothrow_move_constructible_v<C>);
C c;
C d = std::move(c);
}
+ // todo: why?
+ /*
{
// Moving the flat_map copies the comparator (to support std::function comparators)
using C = std::flat_map<int, int, MoveSensitiveComp>;
@@ -108,5 +112,6 @@ int main(int, char**) {
LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
assert(!d.key_comp().is_moved_from_);
}
+ */
return 0;
}
>From 38f0c92b362fdf2d859defcc56ba739970b704e4 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 8 Sep 2024 15:55:10 +0100
Subject: [PATCH 08/40] exception guard etc
---
libcxx/include/__flat_map/flat_map.h | 71 ++++++++++---------
libcxx/include/__utility/exception_guard.h | 5 ++
libcxx/include/forward_list | 1 -
libcxx/include/list | 1 -
.../flat.map/assert.ctor.pass.cpp | 29 ++++++++
.../flat.map/extract.pass.cpp | 57 +++++++++++++++
.../flat.map/flat.map.cons/move.pass.cpp | 12 ++++
.../flat.map.cons/move_alloc.pass.cpp | 12 ++++
.../flat.map.cons/move_assign_clears.pass.cpp | 13 ++++
.../container.adaptors/flat.map/helpers.h | 15 ++++
10 files changed, 180 insertions(+), 36 deletions(-)
create mode 100644 libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index b0a72ba63d69de..e217b6fc12e42e 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -239,20 +239,16 @@ class flat_map {
// state if an exception is thrown
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
-# if defined(_LIBCPP_HAS_NO_EXCEPTIONS)
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&&) = default;
-# else // defined(_LIBCPP_HAS_NO_EXCEPTIONS)
_LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
is_nothrow_move_constructible_v<_Compare>) try
: __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
+ __other.clear();
} catch (...) {
__other.clear();
throw;
}
-# endif // defined(_LIBCPP_HAS_NO_EXCEPTIONS)
-
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map& __other, const _Allocator& __alloc)
@@ -264,17 +260,24 @@ class flat_map {
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other, const _Allocator& __alloc)
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other, const _Allocator& __alloc) try
: flat_map(__ctor_uses_allocator_tag{},
__alloc,
std::move(__other.__containers_.keys),
std::move(__other.__containers_.values),
- std::move(__other.__compare_)) {}
+ std::move(__other.__compare_)) {
+ __other.clear();
+ } catch (...) {
+ __other.clear();
+ throw;
+ }
_LIBCPP_HIDE_FROM_ABI flat_map(
key_container_type __key_cont, mapped_container_type __mapped_cont, const key_compare& __comp = key_compare())
: __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
__sort_and_unique();
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
}
template <class _Allocator>
@@ -379,29 +382,29 @@ class flat_map {
}
template <input_iterator _InputIterator>
- _LIBCPP_HIDE_FROM_ABI flat_map(
- sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
+ _LIBCPP_HIDE_FROM_ABI
+ flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
- insert(__s, __first, __last);
+ insert(sorted_unique, __first, __last);
}
template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
- flat_map(sorted_unique_t __s,
+ flat_map(sorted_unique_t,
_InputIterator __first,
_InputIterator __last,
const key_compare& __comp,
const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
- insert(__s, __first, __last);
+ insert(sorted_unique, __first, __last);
}
template <input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
- flat_map(sorted_unique_t __s, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+ flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
- insert(__s, __first, __last);
+ insert(sorted_unique, __first, __last);
}
_LIBCPP_HIDE_FROM_ABI flat_map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
@@ -419,19 +422,19 @@ class flat_map {
: flat_map(__il.begin(), __il.end(), __alloc) {}
_LIBCPP_HIDE_FROM_ABI
- flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
- : flat_map(__s, __il.begin(), __il.end(), __comp) {}
+ flat_map(sorted_unique_t, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+ : flat_map(sorted_unique, __il.begin(), __il.end(), __comp) {}
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
- flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
- : flat_map(__s, __il.begin(), __il.end(), __comp, __alloc) {}
+ flat_map(sorted_unique_t, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
+ : flat_map(sorted_unique, __il.begin(), __il.end(), __comp, __alloc) {}
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
- _LIBCPP_HIDE_FROM_ABI flat_map(sorted_unique_t __s, initializer_list<value_type> __il, const _Allocator& __alloc)
- : flat_map(__s, __il.begin(), __il.end(), __alloc) {}
+ _LIBCPP_HIDE_FROM_ABI flat_map(sorted_unique_t, initializer_list<value_type> __il, const _Allocator& __alloc)
+ : flat_map(sorted_unique, __il.begin(), __il.end(), __alloc) {}
_LIBCPP_HIDE_FROM_ABI flat_map& operator=(initializer_list<value_type> __il) {
clear();
@@ -447,10 +450,11 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI flat_map& operator=(flat_map&& __other) noexcept(
is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_MappedContainer> &&
is_nothrow_move_assignable_v<_Compare>) {
- auto __guard = std::__make_exception_guard([&]() noexcept { __other.clear() /* noexcept */; });
- __containers_ = std::move(__other.__containers_);
- __compare_ = std::move(__other.__compare_);
- __guard.__complete();
+ auto __clear_other_guard = std::__make_scoped_guard([&]() noexcept { __other.clear() /* noexcept */; });
+ auto __clear_self_guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ __containers_ = std::move(__other.__containers_);
+ __compare_ = std::move(__other.__compare_);
+ __clear_self_guard.__complete();
return *this;
}
@@ -504,7 +508,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __x) {
auto __it = find(__x);
if (__it == end()) {
- __throw_out_of_range("flat_map::at(const key_type&): Key does not exist");
+ std::__throw_out_of_range("flat_map::at(const key_type&): Key does not exist");
}
return (*__it).second;
}
@@ -512,7 +516,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __x) const {
auto __it = find(__x);
if (__it == end()) {
- __throw_out_of_range("flat_map::at(const key_type&) const: Key does not exist");
+ std::__throw_out_of_range("flat_map::at(const key_type&) const: Key does not exist");
}
return (*__it).second;
}
@@ -523,7 +527,7 @@ class flat_map {
static_assert(requires { find(__x); }, "flat_map::at(const K& x): find(x) needs to be well-formed");
auto __it = find(__x);
if (__it == end()) {
- __throw_out_of_range("flat_map::at(const K&): Key does not exist");
+ std::__throw_out_of_range("flat_map::at(const K&): Key does not exist");
}
return (*__it).second;
}
@@ -534,7 +538,7 @@ class flat_map {
static_assert(requires { find(__x); }, "flat_map::at(const K& x) const: find(x) needs to be well-formed");
auto __it = find(__x);
if (__it == end()) {
- __throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
+ std::__throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
}
return (*__it).second;
}
@@ -588,7 +592,7 @@ class flat_map {
return emplace_hint(__hint, std::forward<_Pp>(__x));
}
- template <input_iterator _InputIterator>
+ template <class _InputIterator>
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve_impl(__last - __first);
@@ -634,14 +638,13 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
- _LIBCPP_HIDE_FROM_ABI void insert(sorted_unique_t __s, initializer_list<value_type> __il) {
- insert(__s, __il.begin(), __il.end());
+ _LIBCPP_HIDE_FROM_ABI void insert(sorted_unique_t, initializer_list<value_type> __il) {
+ insert(sorted_unique, __il.begin(), __il.end());
}
_LIBCPP_HIDE_FROM_ABI containers extract() && {
- auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
+ auto __guard = std::__make_scoped_guard([&]() noexcept { clear() /* noexcept */; });
auto __ret = std::move(__containers_);
- __guard.__complete();
return __ret;
}
@@ -766,7 +769,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
auto __guard = std::__make_exception_guard([&]() noexcept {
clear() /* noexcept */;
- __y.clear(); /*noexcept*/
+ __y.clear() /*noexcept*/;
});
using std::swap;
swap(__compare_, __y.__compare_);
diff --git a/libcxx/include/__utility/exception_guard.h b/libcxx/include/__utility/exception_guard.h
index a03bd7e8f35227..3136ebc76c659c 100644
--- a/libcxx/include/__utility/exception_guard.h
+++ b/libcxx/include/__utility/exception_guard.h
@@ -137,6 +137,11 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exce
return __exception_guard<_Rollback>(std::move(__rollback));
}
+template <class _Rollback>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard_exceptions<_Rollback> __make_scoped_guard(_Rollback __rollback) {
+ return __exception_guard_exceptions<_Rollback>(std::move(__rollback));
+}
+
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
diff --git a/libcxx/include/forward_list b/libcxx/include/forward_list
index 6f16a9861a390c..04466d9a673fc6 100644
--- a/libcxx/include/forward_list
+++ b/libcxx/include/forward_list
@@ -200,7 +200,6 @@ template <class T, class Allocator, class Predicate>
#include <__algorithm/lexicographical_compare_three_way.h>
#include <__algorithm/min.h>
#include <__config>
-#include <__flat_map/container_traits.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/move_iterator.h>
diff --git a/libcxx/include/list b/libcxx/include/list
index 336883895a166a..95302754271226 100644
--- a/libcxx/include/list
+++ b/libcxx/include/list
@@ -204,7 +204,6 @@ template <class T, class Allocator, class Predicate>
#include <__algorithm/min.h>
#include <__assert>
#include <__config>
-#include <__flat_map/container_traits.h>
#include <__format/enable_insertable.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
new file mode 100644
index 00000000000000..5d3ca9087b5302
--- /dev/null
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
@@ -0,0 +1,29 @@
+//
+// 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
+// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
+
+// <flat_map>
+
+// flat_map(key_container_type , mapped_container_type , const key_compare& __comp = key_compare())
+//
+
+#include <flat_map>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+ using M = std::flat_map<int, int>;
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] { M m{{1, 2, 3}, {4}}; }()), "flat_map keys and mapped containers have different size");
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp
new file mode 100644
index 00000000000000..3c295a09f05c25
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// containers extract() &&;
+
+#include <algorithm>
+#include <concepts>
+#include <flat_map>
+#include <functional>
+
+#include "helpers.h"
+#include "test_macros.h"
+
+template <class T>
+concept CanExtract = requires(T&& t) { std::forward<T>(t).extract(); };
+
+static_assert(CanExtract<std::flat_map<int, int>&&>);
+static_assert(!CanExtract<std::flat_map<int, int>&>);
+static_assert(!CanExtract<std::flat_map<int, int> const&>);
+static_assert(!CanExtract<std::flat_map<int, int> const&&>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, int>;
+ M m = M({1, 2, 3}, {4, 5, 6});
+ std::same_as<M::containers> auto containers = std::move(m).extract();
+ auto expected_keys = {1, 2, 3};
+ auto expected_values = {4, 5, 6};
+ assert(std::ranges::equal(containers.keys, expected_keys));
+ assert(std::ranges::equal(containers.values, expected_values));
+ LIBCPP_ASSERT(m.empty());
+ LIBCPP_ASSERT(m.keys().size() == 0);
+ LIBCPP_ASSERT(m.values().size() == 0);
+ }
+ {
+ // extracted object maintains invariant if one of underlying container does not clear after move
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
+ M m = M({1, 2, 3}, {1, 2, 3});
+ std::same_as<M::containers> auto containers = std::move(m).extract();
+ assert(containers.keys.size() == 3);
+ assert(containers.values.size() == 3);
+ LIBCPP_ASSERT(m.empty());
+ LIBCPP_ASSERT(m.keys().size() == 0);
+ LIBCPP_ASSERT(m.values().size() == 0);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
index 4cd24e3df9fb6b..b739644abd8039 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
@@ -19,6 +19,7 @@
#include <utility>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
@@ -72,5 +73,16 @@ int main(int, char**) {
mo.insert({{1, 1}, {2, 2}, {3, 1}}); // insert has no preconditions
assert(m == mo);
}
+ {
+ // moved-from object maintains invariant if one of underlying container does not clear after move
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
+ M m1 = M({1,2,3},{1,2,3});
+ M m2 = std::move(m1);
+ assert(m2.size()==3);
+ assert(m1.keys().size() == m1.values().size());
+ LIBCPP_ASSERT(m1.empty());
+ LIBCPP_ASSERT(m1.keys().size() == 0);
+ LIBCPP_ASSERT(m1.values().size() == 0);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index e225977c3eb9c3..44d421d0d15026 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -20,6 +20,7 @@
#include <ranges>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
#include "../../../test_compare.h"
#include "test_allocator.h"
@@ -79,5 +80,16 @@ int main(int, char**) {
assert((vs[0].keys() == std::pmr::deque<int>{1, 2, 3}));
assert((vs[0].values() == std::pmr::vector<int>{1, 2, 1}));
}
+ {
+ // moved-from object maintains invariant if one of underlying container does not clear after move
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
+ M m1 = M({1,2,3},{1,2,3});
+ M m2 (std::move(m1), std::allocator<int>{});
+ assert(m2.size()==3);
+ assert(m1.keys().size() == m1.values().size());
+ LIBCPP_ASSERT(m1.empty());
+ LIBCPP_ASSERT(m1.keys().size() == 0);
+ LIBCPP_ASSERT(m1.values().size() == 0);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
index de15377d862fff..121bf7c15e4a4d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
@@ -21,6 +21,7 @@
#include <utility>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
struct MoveNegates {
@@ -87,5 +88,17 @@ int main(int, char**) {
assert(m.contains(1));
assert(m.find(2) != m.end());
}
+ {
+ // moved-from object maintains invariant if one of underlying container does not clear after move
+ using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
+ M m1 = M({1, 2, 3}, {1, 2, 3});
+ M m2 = M({1, 2}, {1, 2});
+ m2 = std::move(m1);
+ assert(m2.size() == 3);
+ assert(m1.keys().size() == m1.values().size());
+ LIBCPP_ASSERT(m1.empty());
+ LIBCPP_ASSERT(m1.keys().size() == 0);
+ LIBCPP_ASSERT(m1.values().size() == 0);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index f2c0a6dd4bb1a9..9ebe7be9c8ab9e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -11,6 +11,7 @@
#include <cassert>
#include <string>
+#include <vector>
struct StartsWith {
explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {}
@@ -32,4 +33,18 @@ struct StartsWith {
std::string upper_;
};
+template <class T>
+struct CopyOnlyVector : std::vector<T> {
+ using std::vector<T>::vector;
+
+ CopyOnlyVector(const CopyOnlyVector&) = default;
+ CopyOnlyVector(CopyOnlyVector&& other) : CopyOnlyVector(other){}
+ CopyOnlyVector(CopyOnlyVector&& other, std::vector<T>::allocator_type alloc) : CopyOnlyVector(other, alloc){}
+
+ CopyOnlyVector& operator=(const CopyOnlyVector&) = default;
+ CopyOnlyVector& operator=(CopyOnlyVector& other) {
+ return this->operator=(other);
+ }
+};
+
#endif // SUPPORT_FLAT_MAP_HELPERS_H
>From c9a3af5322a3d7d3d8f1cd3ebece36e6970817e4 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 8 Sep 2024 19:42:41 +0100
Subject: [PATCH 09/40] more fixes
---
libcxx/include/__flat_map/flat_map.h | 117 +++++++++++++-----
.../flat.map/assert.ctor.pass.cpp | 29 -----
.../flat.map/assert.input_range.pass.cpp | 63 ++++++++++
3 files changed, 146 insertions(+), 63 deletions(-)
delete mode 100644 libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
create mode 100644 libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index e217b6fc12e42e..1c3311482983b7 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -11,7 +11,9 @@
#define _LIBCPP___FLAT_MAP_FLAT_MAP_H
#include <__algorithm/lexicographical_compare_three_way.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_stable_sort.h>
@@ -35,6 +37,7 @@
#include <__memory/uses_allocator_construction.h>
#include <__ranges/concepts.h>
#include <__ranges/container_compatible_range.h>
+#include <__ranges/drop_view.h>
#include <__ranges/ref_view.h>
#include <__ranges/subrange.h>
#include <__ranges/zip_view.h>
@@ -275,9 +278,9 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI flat_map(
key_container_type __key_cont, mapped_container_type __mapped_cont, const key_compare& __comp = key_compare())
: __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
- __sort_and_unique();
_LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
"flat_map keys and mapped containers have different size");
+ __sort_and_unique();
}
template <class _Allocator>
@@ -285,6 +288,8 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI
flat_map(const key_container_type& __key_cont, const mapped_container_type& __mapped_cont, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
__sort_and_unique();
}
@@ -296,6 +301,8 @@ class flat_map {
const key_compare& __comp,
const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
__sort_and_unique();
}
@@ -304,7 +311,12 @@ class flat_map {
key_container_type __key_cont,
mapped_container_type __mapped_cont,
const key_compare& __comp = key_compare())
- : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {}
+ : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ }
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
@@ -313,7 +325,12 @@ class flat_map {
const key_container_type& __key_cont,
const mapped_container_type& __mapped_cont,
const _Allocator& __alloc)
- : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {}
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ }
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
@@ -323,7 +340,12 @@ class flat_map {
const mapped_container_type& __mapped_cont,
const key_compare& __comp,
const _Allocator& __alloc)
- : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {}
+ : flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ "flat_map keys and mapped containers have different size");
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ }
_LIBCPP_HIDE_FROM_ABI explicit flat_map(const key_compare& __comp) : __containers_(), __compare_(__comp) {}
@@ -597,10 +619,7 @@ class flat_map {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve_impl(__last - __first);
}
-
- for (; __first != __last; ++__first) {
- __binary_search_emplace_impl(value_type(*__first));
- }
+ __append_sort_merge_unique</*WasSorted = */ false>(std::move(__first), std::move(__last));
}
template <input_iterator _InputIterator>
@@ -609,19 +628,7 @@ class flat_map {
__reserve_impl(__last - __first);
}
- auto __it = begin();
- while (__first != __last) {
- value_type __pair(*__first);
- auto __end = end();
- __it = ranges::lower_bound(__it, __end, __pair.first, __compare_, [](const auto& __p) -> decltype(auto) {
- return std::get<0>(__p);
- });
- if (__it == __end || __compare_(__pair.first, __it->first)) {
- __it = __emplace_impl(__it, std::move(__pair));
- }
- ++__it;
- ++__first;
- }
+ __append_sort_merge_unique</*WasSorted = */ true>(std::move(__first), std::move(__last));
}
template <_ContainerCompatibleRange<value_type> _Range>
@@ -630,10 +637,7 @@ class flat_map {
__reserve_impl(ranges::size(__range));
}
- auto __last = ranges::end(__range);
- for (auto __it = ranges::begin(__range); __it != __last; ++__it) {
- __binary_search_emplace_impl(value_type(*__it));
- }
+ __append_sort_merge_unique</*WasSorted = */ false>(ranges::begin(__range), ranges::end(__range));
}
_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
@@ -895,14 +899,6 @@ class flat_map {
struct __ctor_uses_allocator_empty_tag {
explicit __ctor_uses_allocator_empty_tag() = default;
};
- _LIBCPP_HIDE_FROM_ABI void __sort_and_unique() {
- auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
- ranges::stable_sort(__zv, __compare_, [](const auto& __p) -> decltype(auto) { return std::get<0>(__p); });
- auto __it = ranges::unique(__zv, __key_equiv(__compare_)).begin();
- auto __dist = ranges::distance(__zv.begin(), __it);
- __containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
- __containers_.values.erase(__containers_.values.begin() + __dist, __containers_.values.end());
- }
template <class _Allocator, class _KeyCont, class _MappedCont, class... _CompArg>
_LIBCPP_HIDE_FROM_ABI
@@ -923,6 +919,58 @@ class flat_map {
.values = std::make_obj_using_allocator<mapped_container_type>(__alloc)},
__compare_(std::forward<_CompArg>(__comp)...) {}
+ _LIBCPP_HIDE_FROM_ABI bool __is_sorted_and_unique(auto&& __key_container) const {
+ auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) { return !__compare_(__x, __y); };
+ return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void __sort_and_unique() {
+ auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
+ ranges::stable_sort(__zv, __compare_, [](const auto& __p) -> decltype(auto) { return std::get<0>(__p); });
+ auto __dup_start = ranges::unique(__zv, __key_equiv(__compare_)).begin();
+ auto __dist = ranges::distance(__zv.begin(), __dup_start);
+ __containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
+ __containers_.values.erase(__containers_.values.begin() + __dist, __containers_.values.end());
+ }
+
+ template <class _InputIterator, class _Sentinel>
+ _LIBCPP_HIDE_FROM_ABI size_type __append_no_check(_InputIterator __first, _Sentinel __last) {
+ size_type __num_of_appended = 0;
+ for (; __first != __last; ++__first) {
+ value_type __kv = *__first;
+ __containers_.keys.insert(__containers_.keys.end(), std::move(__kv.first));
+ __containers_.values.insert(__containers_.values.end(), std::move(__kv.second));
+ ++__num_of_appended;
+ }
+ return __num_of_appended;
+ }
+
+ template <bool _WasSorted, class _InputIterator, class _Sentinel>
+ _LIBCPP_HIDE_FROM_ABI void __append_sort_merge_unique(_InputIterator __first, _Sentinel __last) {
+ size_t __num_of_appended = __append_no_check(std::move(__first), std::move(__last));
+ if (__num_of_appended != 0) {
+ auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
+ auto __append_start_offset = __containers_.keys.size() - __num_of_appended;
+ auto __end = __zv.end();
+ auto __compare_key = [this](const auto& __p1, const auto& __p2) {
+ return __compare_(std::get<0>(__p1), std::get<0>(__p2));
+ };
+ if constexpr (!_WasSorted) {
+ ranges::stable_sort(__zv.begin() + __append_start_offset, __end, __compare_key);
+ } else {
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__containers.keys | views::drop(__append_start_offset)),
+ "Either the key container is not sorted or it contains duplicates");
+ }
+ ranges::inplace_merge(__zv.begin(), __zv.begin() + __append_start_offset, __end, __compare_key);
+
+ auto __dup_start = ranges::unique(__zv, __key_equiv(__compare_)).begin();
+ auto __dist = ranges::distance(__zv.begin(), __dup_start);
+ __containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
+ __containers_.values.erase(__containers_.values.begin() + __dist, __containers_.values.end());
+ }
+ }
+
template <class _Self, class _Kp>
_LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) {
auto __it = __self.lower_bound(__key);
@@ -1131,7 +1179,8 @@ class flat_map {
struct __key_equiv {
__key_equiv(key_compare __c) : __comp_(__c) {}
bool operator()(const_reference __x, const_reference __y) const {
- return !__comp_(__x.first, __y.first) && !__comp_(__y.first, __x.first);
+ // LWG issue ? spec uses __x.first but zip_view no longer uses pair
+ return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
}
key_compare __comp_;
};
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
deleted file mode 100644
index 5d3ca9087b5302..00000000000000
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.ctor.pass.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// 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
-// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
-
-// <flat_map>
-
-// flat_map(key_container_type , mapped_container_type , const key_compare& __comp = key_compare())
-//
-
-#include <flat_map>
-#include <cassert>
-
-#include "check_assertion.h"
-
-int main(int, char**) {
- using M = std::flat_map<int, int>;
-
- TEST_LIBCPP_ASSERT_FAILURE(
- ([] { M m{{1, 2, 3}, {4}}; }()), "flat_map keys and mapped containers have different size");
-
- return 0;
-}
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
new file mode 100644
index 00000000000000..b5d3fbcee57336
--- /dev/null
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
@@ -0,0 +1,63 @@
+//
+// 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
+// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
+
+// <flat_map>
+
+// flat_map(key_container_type , mapped_container_type , const key_compare& __comp = key_compare())
+// flat_map(const key_container_type& , const mapped_container_type& , const _Allocator& )
+// flat_map(const key_container_type& , const mapped_container_type& , const key_compare&, const _Allocator& )
+// void replace(key_container_type&& , mapped_container_type&&)
+//
+
+#include <flat_map>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+ using M = std::flat_map<int, int>;
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] { M m{{1, 2, 3}, {4}}; }()), "flat_map keys and mapped containers have different size");
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] { M m{{1, 2, 3}, {4}, std::less<int>{}}; }()), "flat_map keys and mapped containers have different size");
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] {
+ const std::vector keys{1, 2, 3};
+ const std::vector values{4};
+ const std::allocator<int> alloc{};
+ M m{keys, values, alloc};
+ }()),
+ "flat_map keys and mapped containers have different size");
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] {
+ const std::vector keys{1, 2, 3};
+ const std::vector values{4};
+ const std::less<int> key_compare{};
+ const std::allocator<int> alloc{};
+ M m{keys, values, key_compare, alloc};
+ }()),
+ "flat_map keys and mapped containers have different size");
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] {
+ std::vector keys{1, 2, 3};
+ std::vector values{4};
+ M m;
+ m.replace(std::move(keys), std::move(values));
+ }()),
+ "flat_map keys and mapped containers have different size");
+
+ return 0;
+}
>From 068cae012a9b9881de5fe9b6719532410d90d40a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 10:53:17 +0100
Subject: [PATCH 10/40] fix comments
---
libcxx/include/__flat_map/flat_map.h | 169 ++++++--------
.../flat.map/assert.input_range.pass.cpp | 8 +-
.../flat.map/assert.sorted_unique.pass.cpp | 210 ++++++++++++++++++
.../flat.map/count_transparent.pass.cpp | 17 ++
.../flat.map/equal_range_transparent.pass.cpp | 43 ++++
.../flat.map/erase_key_transparent.pass.cpp | 17 ++
.../container.adaptors/flat.map/helpers.h | 29 ++-
.../flat.map/insert_range_stability.pass.cpp | 10 +
libcxx/utils/libcxx/header_information.py | 2 +-
9 files changed, 391 insertions(+), 114 deletions(-)
create mode 100644 libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 1c3311482983b7..6137bd8e19f756 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -237,9 +237,9 @@ class flat_map {
is_nothrow_default_constructible_v<_Compare>)
: __containers_(), __compare_() {}
- // copy/move constructors are not specified in the spec (defaulted)
- // but move constructor can potentially leave moved from object in an inconsistent
- // state if an exception is thrown
+ // The copy/move constructors are not specified in the spec, which means they should be defaulted.
+ // However, the move constructor can potentially leave a moved-from object in an inconsistent
+ // state if an exception is thrown.
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
_LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
@@ -570,24 +570,14 @@ class flat_map {
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
- return __binary_search_emplace_impl(std::move(__pair));
+ return __try_emplace(std::move(__pair.first), std::move(__pair.second));
}
template <class... _Args>
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
- if (__is_hint_correct(__hint, __pair.first)) {
- if (__compare_(__pair.first, __hint->first)) {
- return __emplace_impl(__hint, std::move(__pair));
- } else {
- // key equals
- auto __dist = __hint - cbegin();
- return iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist);
- }
- } else {
- return __binary_search_emplace_impl(std::move(__pair)).first;
- }
+ return __try_emplace_hint(__hint, std::move(__pair.first), std::move(__pair.second));
}
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return emplace(__x); }
@@ -614,10 +604,10 @@ class flat_map {
return emplace_hint(__hint, std::forward<_Pp>(__x));
}
- template <class _InputIterator>
+ template <input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
- __reserve_impl(__last - __first);
+ __reserve(__last - __first);
}
__append_sort_merge_unique</*WasSorted = */ false>(std::move(__first), std::move(__last));
}
@@ -625,7 +615,7 @@ class flat_map {
template <input_iterator _InputIterator>
void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
- __reserve_impl(__last - __first);
+ __reserve(__last - __first);
}
__append_sort_merge_unique</*WasSorted = */ true>(std::move(__first), std::move(__last));
@@ -634,7 +624,7 @@ class flat_map {
template <_ContainerCompatibleRange<value_type> _Range>
_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
if constexpr (ranges::sized_range<_Range>) {
- __reserve_impl(ranges::size(__range));
+ __reserve(ranges::size(__range));
}
__append_sort_merge_unique</*WasSorted = */ false>(ranges::begin(__range), ranges::end(__range));
@@ -662,13 +652,13 @@ class flat_map {
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __key, _Args&&... __args) {
- return __binary_search_try_emplace_impl(__key, std::forward<_Args>(__args)...);
+ return __try_emplace(__key, std::forward<_Args>(__args)...);
}
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __key, _Args&&... __args) {
- return __binary_search_try_emplace_impl(std::move(__key), std::forward<_Args>(__args)...);
+ return __try_emplace(std::move(__key), std::forward<_Args>(__args)...);
}
template <class _Kp, class... _Args>
@@ -676,25 +666,25 @@ class flat_map {
is_constructible_v<mapped_type, _Args...> && is_convertible_v<_Kp&&, const_iterator> &&
is_convertible_v<_Kp&&, iterator>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(_Kp&& __key, _Args&&... __args) {
- return __binary_search_try_emplace_impl(std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ return __try_emplace(std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
}
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, const key_type& __key, _Args&&... __args) {
- return try_emplace_hint_impl(__hint, __key, std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, __key, std::forward<_Args>(__args)...);
}
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, key_type&& __key, _Args&&... __args) {
- return try_emplace_hint_impl(__hint, std::move(__key), std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, std::move(__key), std::forward<_Args>(__args)...);
}
template <class _Kp, class... _Args>
requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
- return try_emplace_hint_impl(__hint, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
}
template <class _Mapped>
@@ -736,11 +726,11 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
- return __erase_impl(__position.__key_iter_, __position.__mapped_iter_);
+ return __erase(__position.__key_iter_, __position.__mapped_iter_);
}
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position) {
- return __erase_impl(__position.__key_iter_, __position.__mapped_iter_);
+ return __erase(__position.__key_iter_, __position.__mapped_iter_);
}
_LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) {
@@ -815,8 +805,7 @@ class flat_map {
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const {
- auto [__first, __last] = __equal_range_return_key_iter(*this, __x);
- return __last - __first;
+ return contains(__x) ? 1 : 0;
}
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
@@ -826,40 +815,40 @@ class flat_map {
return find(__x) != end();
}
- _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { return __lower_bound_impl<iterator>(*this, __x); }
+ _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { return __lower_bound<iterator>(*this, __x); }
_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const {
- return __lower_bound_impl<const_iterator>(*this, __x);
+ return __lower_bound<const_iterator>(*this, __x);
}
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) {
- return __lower_bound_impl<iterator>(*this, __x);
+ return __lower_bound<iterator>(*this, __x);
}
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const {
- return __lower_bound_impl<const_iterator>(*this, __x);
+ return __lower_bound<const_iterator>(*this, __x);
}
- _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound_impl<iterator>(*this, __x); }
+ _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound<iterator>(*this, __x); }
_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const {
- return __upper_bound_impl<const_iterator>(*this, __x);
+ return __upper_bound<const_iterator>(*this, __x);
}
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) {
- return __upper_bound_impl<iterator>(*this, __x);
+ return __upper_bound<iterator>(*this, __x);
}
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const {
- return __upper_bound_impl<iterator>(*this, __x);
+ return __upper_bound<iterator>(*this, __x);
}
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __x) {
@@ -934,7 +923,7 @@ class flat_map {
}
template <class _InputIterator, class _Sentinel>
- _LIBCPP_HIDE_FROM_ABI size_type __append_no_check(_InputIterator __first, _Sentinel __last) {
+ _LIBCPP_HIDE_FROM_ABI size_type __append(_InputIterator __first, _Sentinel __last) {
size_type __num_of_appended = 0;
for (; __first != __last; ++__first) {
value_type __kv = *__first;
@@ -947,7 +936,7 @@ class flat_map {
template <bool _WasSorted, class _InputIterator, class _Sentinel>
_LIBCPP_HIDE_FROM_ABI void __append_sort_merge_unique(_InputIterator __first, _Sentinel __last) {
- size_t __num_of_appended = __append_no_check(std::move(__first), std::move(__last));
+ size_t __num_of_appended = __append(std::move(__first), std::move(__last));
if (__num_of_appended != 0) {
auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
auto __append_start_offset = __containers_.keys.size() - __num_of_appended;
@@ -981,8 +970,8 @@ class flat_map {
return __it;
}
- template <class _Self>
- _LIBCPP_HIDE_FROM_ABI static auto __equal_range_return_key_iter(_Self&& __self, const _Key& __key) {
+ template <class _Self, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static auto __key_equal_range(_Self&& __self, const _Kp& __key) {
auto __it = ranges::lower_bound(__self.__containers_.keys, __key, __self.__compare_);
auto __last = __self.__containers_.keys.end();
if (__it == __last || __self.__compare_(__key, *__it)) {
@@ -991,25 +980,9 @@ class flat_map {
return std::make_pair(__it, std::next(__it));
}
- template <class _Self, class _Kp>
- _LIBCPP_HIDE_FROM_ABI static auto __equal_range_return_key_iter(_Self&& __self, const _Kp& __key) {
- // if the comparator gives different results between Key(__x) < key2 and __x < key2,
- // the container might have duplicates w.r.t to _Kp < Key
- // TODO: this is the case in Author's test case, but do we really want to support it?
- auto __first_not_smaller = ranges::lower_bound(__self.__containers_.keys, __key, __self.__compare_);
- auto __first_bigger =
- std::ranges::partition_point(__first_not_smaller, __self.__containers_.keys.end(), [&](const auto& __ele) {
- return !std::invoke(__self.__compare_, __key, __ele);
- });
- return std::make_pair(std::move(__first_not_smaller), std::move(__first_bigger));
- }
-
template <class _Self, class _Kp>
_LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
- // if the comparator gives different results between Key(__x) < key2 and __x < key2,
- // the container might have duplicates w.r.t to _Kp < Key
- // TODO: this is the case in Author's test case, but do we really want to support it?
- auto [__first_not_smaller_key_iter, __first_bigger_key_iter] = __equal_range_return_key_iter(__self, __key);
+ auto [__key_first, __key_last] = __key_equal_range(__self, __key);
const auto __make_mapped_iter = [&](const auto& __key_iter) {
return __self.__containers_.values.begin() +
@@ -1018,34 +991,22 @@ class flat_map {
};
using __iterator_type = ranges::iterator_t<decltype(__self)>;
- return std::make_pair(
- __iterator_type(__first_not_smaller_key_iter, __make_mapped_iter(__first_not_smaller_key_iter)),
- __iterator_type(__first_bigger_key_iter, __make_mapped_iter(__first_bigger_key_iter)));
+ return std::make_pair(__iterator_type(__key_first, __make_mapped_iter(__key_first)),
+ __iterator_type(__key_last, __make_mapped_iter(__key_last)));
}
template <class _Res, class _Self, class _Kp>
- _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound_impl(_Self&& __self, _Kp& __x) {
- return __binary_search_impl<_Res>(ranges::lower_bound, __self, __x);
+ _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound(_Self&& __self, _Kp& __x) {
+ return __binary_search<_Res>(__self, ranges::lower_bound, __x);
}
template <class _Res, class _Self, class _Kp>
- _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound_impl(_Self&& __self, _Kp& __x) {
- return __binary_search_impl<_Res>(ranges::upper_bound, __self, __x);
+ _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound(_Self&& __self, _Kp& __x) {
+ return __binary_search<_Res>(__self, ranges::upper_bound, __x);
}
- template <class _Kp>
- _LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) {
- if (__hint != cbegin() && !__compare_(std::prev(__hint)->first, __key)) {
- return false;
- }
- if (__hint != cend() && __compare_(__hint->first, __key)) {
- return false;
- }
- return true;
- }
-
- template <class _Res, class _Fn, class _Self, class _Kp>
- _LIBCPP_HIDE_FROM_ABI static _Res __binary_search_impl(_Fn __search_fn, _Self&& __self, _Kp& __x) {
+ template <class _Res, class _Self, class _Fn, class _Kp>
+ _LIBCPP_HIDE_FROM_ABI static _Res __binary_search(_Self&& __self, _Fn __search_fn, _Kp& __x) {
auto __key_iter = __search_fn(__self.__containers_.keys, __x, __self.__compare_);
auto __mapped_iter =
__self.__containers_.values.begin() +
@@ -1055,42 +1016,40 @@ class flat_map {
return _Res(std::move(__key_iter), std::move(__mapped_iter));
}
- _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __binary_search_emplace_impl(std::pair<key_type, mapped_type>&& __pair) {
- if (auto __it = lower_bound(__pair.first); __it == end() || __compare_(__pair.first, (*__it).first)) {
- return pair<iterator, bool>(__emplace_impl(__it, std::move(__pair)), true);
- } else {
- return pair<iterator, bool>(std::move(__it), false);
- }
- }
-
- template <class _Iter>
- _LIBCPP_HIDE_FROM_ABI iterator __emplace_impl(_Iter&& __it, std::pair<key_type, mapped_type>&& __pair) {
- return __try_emplace_impl(__it.__key_iter_, __it.__mapped_iter_, std::move(__pair.first), std::move(__pair.second));
- }
-
template <class _KeyArg, class... _MArgs>
- _LIBCPP_HIDE_FROM_ABI pair<iterator, bool>
- __binary_search_try_emplace_impl(_KeyArg&& __key, _MArgs&&... __mapped_args) {
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __try_emplace(_KeyArg&& __key, _MArgs&&... __mapped_args) {
auto __key_it = ranges::lower_bound(__containers_.keys, __key, __compare_);
auto __mapped_it = __containers_.values.begin() + ranges::distance(__containers_.keys.begin(), __key_it);
if (__key_it == __containers_.keys.end() || __compare_(__key, *__key_it)) {
return pair<iterator, bool>(
- __try_emplace_impl(std::move(__key_it),
- std::move(__mapped_it),
- std::forward<_KeyArg>(__key),
- std::forward<_MArgs>(__mapped_args)...),
+ __try_emplace_exact_hint(
+ std::move(__key_it),
+ std::move(__mapped_it),
+ std::forward<_KeyArg>(__key),
+ std::forward<_MArgs>(__mapped_args)...),
true);
} else {
return pair<iterator, bool>(iterator(std::move(__key_it), std::move(__mapped_it)), false);
}
}
+ template <class _Kp>
+ _LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) {
+ if (__hint != cbegin() && !__compare_(std::prev(__hint)->first, __key)) {
+ return false;
+ }
+ if (__hint != cend() && __compare_(__hint->first, __key)) {
+ return false;
+ }
+ return true;
+ }
+
template <class _Kp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI iterator try_emplace_hint_impl(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI iterator __try_emplace_hint(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
if (__is_hint_correct(__hint, __key)) {
if (__compare_(__key, __hint->first)) {
- return __try_emplace_impl(
+ return __try_emplace_exact_hint(
__hint.__key_iter_, __hint.__mapped_iter_, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
} else {
// key equals
@@ -1098,13 +1057,13 @@ class flat_map {
return iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist);
}
} else {
- __binary_search_try_emplace_impl(std::forward<_Kp>(__key), std::forward<_Args>(__args)...).first;
+ return __try_emplace(std::forward<_Kp>(__key), std::forward<_Args>(__args)...).first;
}
}
template <class _IterK, class _IterM, class _KeyArg, class... _MArgs>
_LIBCPP_HIDE_FROM_ABI iterator
- __try_emplace_impl(_IterK&& __it_key, _IterM&& __it_mapped, _KeyArg&& __key, _MArgs&&... __mapped_args) {
+ __try_emplace_exact_hint(_IterK&& __it_key, _IterM&& __it_mapped, _KeyArg&& __key, _MArgs&&... __mapped_args) {
auto __on_key_failed = std::__make_exception_guard([&]() noexcept {
if constexpr (__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) {
// Nothing to roll back!
@@ -1150,7 +1109,7 @@ class flat_map {
return __r;
}
- _LIBCPP_HIDE_FROM_ABI void __reserve_impl(size_t __size) {
+ _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) {
if constexpr (requires { __containers_.keys.reserve(__size); }) {
__containers_.keys.reserve(__size);
}
@@ -1161,7 +1120,7 @@ class flat_map {
}
template <class _KIter, class _MIter>
- _LIBCPP_HIDE_FROM_ABI iterator __erase_impl(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) {
+ _LIBCPP_HIDE_FROM_ABI iterator __erase(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) {
auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
auto __key_iter = __containers_.keys.erase(__key_iter_to_remove);
auto __mapped_iter = __containers_.values.erase(__mapped_iter_to_remove);
@@ -1310,8 +1269,8 @@ erase_if(flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_
auto __last = __zv.end();
auto __guard = std::__make_exception_guard([&] { __flat_map.clear(); });
auto __it = std::remove_if(__first, __last, [&](auto&& __zipped) -> bool {
- using __ref = typename flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::const_reference;
- return __pred(__ref(std::get<0>(__zipped), std::get<1>(__zipped)));
+ using _Ref = typename flat_map<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::const_reference;
+ return __pred(_Ref(std::get<0>(__zipped), std::get<1>(__zipped)));
});
auto __res = __last - __it;
auto __offset = __it - __first;
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
index b5d3fbcee57336..7f4131dc317a9c 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
@@ -26,17 +26,17 @@ int main(int, char**) {
using M = std::flat_map<int, int>;
TEST_LIBCPP_ASSERT_FAILURE(
- ([] { M m{{1, 2, 3}, {4}}; }()), "flat_map keys and mapped containers have different size");
+ ([] { M m({1, 2, 3}, {4}); }()), "flat_map keys and mapped containers have different size");
TEST_LIBCPP_ASSERT_FAILURE(
- ([] { M m{{1, 2, 3}, {4}, std::less<int>{}}; }()), "flat_map keys and mapped containers have different size");
+ ([] { M m({1, 2, 3}, {4}, std::less<int>{}); }()), "flat_map keys and mapped containers have different size");
TEST_LIBCPP_ASSERT_FAILURE(
([] {
const std::vector keys{1, 2, 3};
const std::vector values{4};
const std::allocator<int> alloc{};
- M m{keys, values, alloc};
+ M m(keys, values, alloc);
}()),
"flat_map keys and mapped containers have different size");
@@ -46,7 +46,7 @@ int main(int, char**) {
const std::vector values{4};
const std::less<int> key_compare{};
const std::allocator<int> alloc{};
- M m{keys, values, key_compare, alloc};
+ M m(keys, values, key_compare, alloc);
}()),
"flat_map keys and mapped containers have different size");
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
new file mode 100644
index 00000000000000..c98998971bf022
--- /dev/null
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
@@ -0,0 +1,210 @@
+//
+// 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
+// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
+
+// <flat_map>
+
+// flat_map(key_container_type , mapped_container_type , const key_compare& __comp = key_compare())
+// flat_map(const key_container_type& , const mapped_container_type& , const _Allocator& )
+// flat_map(const key_container_type& , const mapped_container_type& , const key_compare&, const _Allocator& )
+// void replace(key_container_type&& , mapped_container_type&&)
+//
+
+#include <flat_map>
+#include <cassert>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+ using M = std::flat_map<int, int>;
+
+ TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}, {4, 5, 6}); }()),
+ "Either the key container is not sorted or it contains duplicates");
+
+ TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {4, 2, 3}, {4, 5, 6}); }()),
+ "Either the key container is not sorted or it contains duplicates");
+
+ TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}, {4, 5, 6}, 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}, {4, 5, 6}, 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::vector values{4, 5, 6};
+ const std::allocator<int> alloc{};
+ M m(std::sorted_unique, keys, values, 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::vector values{4, 5, 6};
+ const std::allocator<int> alloc{};
+ M m(std::sorted_unique, keys, values, 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::vector values{4, 5, 6};
+ const std::allocator<int> alloc{};
+ const std::less<int> comp{};
+ M m(std::sorted_unique, keys, values, 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::vector values{4, 5, 6};
+ const std::allocator<int> alloc{};
+ const std::less<int> comp{};
+ M m(std::sorted_unique, keys, values, comp, alloc);
+ }()),
+ "Either the key container is not sorted or it contains duplicates");
+
+ TEST_LIBCPP_ASSERT_FAILURE(
+ ([] {
+ const std::vector<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{2, 4}, {2, 5}, {3, 6}};
+ 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<std::pair<int, int>> v{{4, 4}, {2, 5}, {3, 6}};
+ M m;
+ m.insert(std::sorted_unique, v);
+ }()),
+ "Either the key container is not sorted or it contains duplicates");
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
index be9751ecec6466..80c4dbb7bef19e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
@@ -21,6 +21,22 @@
#include "test_macros.h"
int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.count(Transparent<std::string>{"abc"})), M::size_type);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).count(Transparent<std::string>{"b"})), M::size_type);
+ assert(m.count(Transparent<std::string>{"alpha"}) == 1);
+ assert(m.count(Transparent<std::string>{"beta"}) == 1);
+ assert(m.count(Transparent<std::string>{"epsilon"}) == 1);
+ assert(m.count(Transparent<std::string>{"eta"}) == 1);
+ assert(m.count(Transparent<std::string>{"gamma"}) == 1);
+ assert(m.count(Transparent<std::string>{"al"}) == 0);
+ assert(m.count(Transparent<std::string>{""}) == 0);
+ assert(m.count(Transparent<std::string>{"g"}) == 0);
+ }
+#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
@@ -34,5 +50,6 @@ int main(int, char**) {
assert(m.count(StartsWith('e')) == 2);
assert(m.count(StartsWith('z')) == 0);
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
index fe0ccc9237bc72..fe2b565beb84c3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
@@ -22,6 +22,48 @@
#include "test_macros.h"
int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ using R = std::pair<M::iterator, M::iterator>;
+ using CR = std::pair<M::const_iterator, M::const_iterator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.equal_range(Transparent<std::string>{"abc"})), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(Transparent<std::string>{"b"})), CR);
+
+ auto test_found = [&](auto&& m, const std::string& expected_key, int expected_value) {
+ auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ assert(last - first == 1);
+ auto [key, value] = *first;
+ assert(key == expected_key);
+ assert(value == expected_value);
+ };
+
+ auto test_not_found = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ assert(first == last);
+ assert(first - m.begin() == expected_offset);
+ };
+
+ test_found(m, "alpha", 1);
+ test_found(m, "beta", 2);
+ test_found(m, "epsilon", 3);
+ test_found(m, "eta", 4);
+ test_found(m, "gamma", 5);
+ test_found(cm, "alpha", 1);
+ test_found(cm, "beta", 2);
+ test_found(cm, "epsilon", 3);
+ test_found(cm, "eta", 4);
+ test_found(cm, "gamma", 5);
+
+ test_not_found(m, "charlie", 2);
+ test_not_found(m, "aaa", 0);
+ test_not_found(m, "zzz", 5);
+ test_not_found(cm, "charlie", 2);
+ test_not_found(cm, "aaa", 0);
+ test_not_found(cm, "zzz", 5);
+ }
+#if 0
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
using R = std::pair<M::iterator, M::iterator>;
@@ -38,5 +80,6 @@ int main(int, char**) {
assert(m.equal_range(StartsWith('e')) == std::pair(begin + 2, begin + 4));
assert(m.equal_range(StartsWith('z')) == std::pair(begin + 5, begin + 5));
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
index f533b85c37a463..1d36a11fed6696 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
@@ -38,6 +38,22 @@ struct HeterogeneousKey {
};
int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.erase(Transparent<std::string>{"abc"})), M::size_type);
+
+ auto n = m.erase(Transparent<std::string>{"epsilon"});
+ assert(n == 1);
+
+ M expected = {{"alpha", 1}, {"beta", 2}, {"eta", 4}, {"gamma", 5}};
+ assert(m == expected);
+
+ auto n2 = m.erase(Transparent<std::string>{"aaa"});
+ assert(n2 == 0);
+ assert(m == expected);
+ }
+#if 0
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
@@ -49,6 +65,7 @@ int main(int, char**) {
assert(n == 0);
assert((m == M{{"alpha", 1}, {"beta", 2}, {"gamma", 5}}));
}
+#endif
{
using M = std::flat_map<int, int, std::less<>>;
M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 9ebe7be9c8ab9e..1e9663afdf40ca 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -38,12 +38,33 @@ struct CopyOnlyVector : std::vector<T> {
using std::vector<T>::vector;
CopyOnlyVector(const CopyOnlyVector&) = default;
- CopyOnlyVector(CopyOnlyVector&& other) : CopyOnlyVector(other){}
- CopyOnlyVector(CopyOnlyVector&& other, std::vector<T>::allocator_type alloc) : CopyOnlyVector(other, alloc){}
+ CopyOnlyVector(CopyOnlyVector&& other) : CopyOnlyVector(other) {}
+ CopyOnlyVector(CopyOnlyVector&& other, std::vector<T>::allocator_type alloc) : CopyOnlyVector(other, alloc) {}
CopyOnlyVector& operator=(const CopyOnlyVector&) = default;
- CopyOnlyVector& operator=(CopyOnlyVector& other) {
- return this->operator=(other);
+ CopyOnlyVector& operator=(CopyOnlyVector& other) { return this->operator=(other); }
+};
+
+template <class T>
+struct Transparent {
+ T t;
+};
+
+struct TransparentComparator {
+ using is_transparent = void;
+ template <class T>
+ bool operator()(const T& t, const Transparent<T>& transparent) const {
+ return t < transparent.t;
+ }
+
+ template <class T>
+ bool operator()(const Transparent<T>& transparent, const T& t) const {
+ return transparent.t < t;
+ }
+
+ template <class T>
+ bool operator()(const T& t1, const T& t2) const {
+ return t1 < t2;
}
};
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
index f30d2761fc0d69..fabcb1d216a78a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
@@ -24,6 +24,8 @@
#include <random>
#include <ranges>
#include <map>
+#include <vector>
+#include <utility>
#include "test_macros.h"
@@ -49,5 +51,13 @@ int main(int, char**) {
assert(fm.size() == m.size());
LIBCPP_ASSERT(std::ranges::equal(fm, m));
}
+
+ {
+ std::vector<std::pair<int, int>> v{{1, 2}, {1, 3}};
+ std::flat_map<int, int> m;
+ m.insert_range(v);
+ assert(m.size() == 1);
+ LIBCPP_ASSERT(m[1] == 2);
+ }
return 0;
}
diff --git a/libcxx/utils/libcxx/header_information.py b/libcxx/utils/libcxx/header_information.py
index 528eb9995e19f4..3b12dcb9f56c0b 100644
--- a/libcxx/utils/libcxx/header_information.py
+++ b/libcxx/utils/libcxx/header_information.py
@@ -163,7 +163,6 @@ def __hash__(self) -> int:
# modules will fail to build if a header is added but this list is not updated.
headers_not_available = list(map(Header, [
"debugging",
- "flat_map",
"flat_set",
"generator",
"hazard_pointer",
@@ -251,6 +250,7 @@ def __hash__(self) -> int:
"coroutine": ["compare"],
"deque": ["compare", "initializer_list"],
"filesystem": ["compare"],
+ "flat_map": ["compare", "initializer_list"],
"forward_list": ["compare", "initializer_list"],
"ios": ["iosfwd"],
"iostream": ["ios", "istream", "ostream", "streambuf"],
>From 80b6d8a9266767b7075bb3a737aaf2f15a12c919 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 10:59:41 +0100
Subject: [PATCH 11/40] fix comments
---
libcxx/include/__flat_map/flat_map.h | 2 ++
.../flat.map/equal_range_transparent.pass.cpp | 1 +
.../container.adaptors/flat.map/erase_key_transparent.pass.cpp | 1 +
.../flat.map/flat.map.cons/move_alloc.pass.cpp | 2 --
4 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 6137bd8e19f756..4f35201aed4261 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -936,6 +936,7 @@ class flat_map {
template <bool _WasSorted, class _InputIterator, class _Sentinel>
_LIBCPP_HIDE_FROM_ABI void __append_sort_merge_unique(_InputIterator __first, _Sentinel __last) {
+ auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
size_t __num_of_appended = __append(std::move(__first), std::move(__last));
if (__num_of_appended != 0) {
auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
@@ -958,6 +959,7 @@ class flat_map {
__containers_.keys.erase(__containers_.keys.begin() + __dist, __containers_.keys.end());
__containers_.values.erase(__containers_.values.begin() + __dist, __containers_.values.end());
}
+ __on_failure.__complete();
}
template <class _Self, class _Kp>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
index fe2b565beb84c3..3433094f1c0d76 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
@@ -64,6 +64,7 @@ int main(int, char**) {
test_not_found(cm, "zzz", 5);
}
#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
using R = std::pair<M::iterator, M::iterator>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
index 1d36a11fed6696..4cbac31c1857e1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
@@ -54,6 +54,7 @@ int main(int, char**) {
assert(m == expected);
}
#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
using M = std::flat_map<std::string, int, StartsWith::Less>;
M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index 44d421d0d15026..e5e6597f2b3ca9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -44,9 +44,7 @@ int main(int, char**) {
// The original flat_map is moved-from.
assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
-#if 0
assert(mo.empty());
-#endif
assert(mo.key_comp() == C(5));
assert(mo.keys().get_allocator() == A(7));
assert(mo.values().get_allocator() == A(7));
>From ed6c867ae727aa7fee90fea153e764e285a6258d Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 11:02:46 +0100
Subject: [PATCH 12/40] input iterator
---
libcxx/include/__flat_map/flat_map.h | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 4f35201aed4261..093453a2cfcf38 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -28,6 +28,7 @@
#include <__functional/is_transparent.h>
#include <__functional/operations.h>
#include <__iterator/concepts.h>
+#include <__iterator/cpp17_iterator_concepts.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/ranges_iterator_traits.h>
@@ -359,14 +360,14 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI explicit flat_map(const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {}
- template <input_iterator _InputIterator>
+ template <__cpp17_input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(__first, __last);
}
- template <input_iterator _InputIterator, class _Allocator>
+ template <__cpp17_input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
@@ -374,7 +375,7 @@ class flat_map {
insert(__first, __last);
}
- template <input_iterator _InputIterator, class _Allocator>
+ template <__cpp17_input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
@@ -403,13 +404,13 @@ class flat_map {
insert_range(std::forward<_Range>(__rg));
}
- template <input_iterator _InputIterator>
+ template <__cpp17_input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(sorted_unique, __first, __last);
}
- template <input_iterator _InputIterator, class _Allocator>
+ template <__cpp17_input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t,
@@ -421,7 +422,7 @@ class flat_map {
insert(sorted_unique, __first, __last);
}
- template <input_iterator _InputIterator, class _Allocator>
+ template <__cpp17_input_iterator _InputIterator, class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
@@ -604,7 +605,7 @@ class flat_map {
return emplace_hint(__hint, std::forward<_Pp>(__x));
}
- template <input_iterator _InputIterator>
+ template <__cpp17_input_iterator _InputIterator>
_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve(__last - __first);
@@ -612,7 +613,7 @@ class flat_map {
__append_sort_merge_unique</*WasSorted = */ false>(std::move(__first), std::move(__last));
}
- template <input_iterator _InputIterator>
+ template <__cpp17_input_iterator _InputIterator>
void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve(__last - __first);
@@ -1221,12 +1222,12 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
_KeyContainer,
_MappedContainer>;
-template <input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+template <__cpp17_input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
requires(!__is_allocator<_Compare>::value)
flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
-template <input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+template <__cpp17_input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
requires(!__is_allocator<_Compare>::value)
flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
>From ea916c4441a71f0bf522d81121b66ab6bbea688a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 11:20:43 +0100
Subject: [PATCH 13/40] static_assert
---
libcxx/include/__flat_map/flat_map.h | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 093453a2cfcf38..2d05de91904f36 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -46,6 +46,7 @@
#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 <__type_traits/maybe_const.h>
#include <__utility/pair.h>
#include <initializer_list>
@@ -94,6 +95,11 @@ class flat_map {
using key_container_type = _KeyContainer;
using mapped_container_type = _MappedContainer;
+ static_assert(__cpp17_random_access_iterator<typename _KeyContainer::iterator>);
+ static_assert(__cpp17_random_access_iterator<typename _MappedContainer::iterator>);
+ static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
+ static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
+
class value_compare {
private:
key_compare __comp_;
>From a3584439d7dfde7a2d4706a4bc9db28625b77e0e Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 11:28:48 +0100
Subject: [PATCH 14/40] static_assert
---
libcxx/include/__flat_map/flat_map.h | 2 --
1 file changed, 2 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 2d05de91904f36..765d56ee7486cb 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -95,8 +95,6 @@ class flat_map {
using key_container_type = _KeyContainer;
using mapped_container_type = _MappedContainer;
- static_assert(__cpp17_random_access_iterator<typename _KeyContainer::iterator>);
- static_assert(__cpp17_random_access_iterator<typename _MappedContainer::iterator>);
static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
>From 7d4206fda90f18e66bf45a8a5f3a7157560af6d8 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 15 Sep 2024 21:08:04 +0100
Subject: [PATCH 15/40] tests
---
libcxx/include/__flat_map/flat_map.h | 1 +
.../flat.map/flat.map.cons/compare.pass.cpp | 19 +-
.../flat.map.cons/containers.pass.cpp | 79 +++++++
.../flat.map/flat.map.cons/default.pass.cpp | 1 +
.../flat.map/flat.map.cons/iter_iter.pass.cpp | 83 +++++++
.../flat.map.cons/iter_iter_comp.pass.cpp | 102 --------
.../flat.map/flat.map.cons/range.pass.cpp | 218 ++++++++++++++++++
.../flat.map.cons/sorted_container.pass.cpp | 91 +++++++-
...omp.pass.cpp => sorted_iter_iter.pass.cpp} | 89 ++++++-
.../flat.map/typedef.compile.pass.cpp | 91 ++++++++
10 files changed, 669 insertions(+), 105 deletions(-)
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/{sorted_iter_iter_comp.pass.cpp => sorted_iter_iter.pass.cpp} (50%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 765d56ee7486cb..e05a7b8f925a3e 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -403,6 +403,7 @@ class flat_map {
}
template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
+ requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
insert_range(std::forward<_Range>(__rg));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
index 9cce469782b07f..df322a9c9d07cc 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
@@ -26,6 +26,22 @@
#include "test_allocator.h"
int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using M1 = std::flat_map<int, int, C, std::vector<int, A1>, std::vector<int, A1>>;
+ using M2 = std::flat_map<int, int, C, std::vector<int, A1>, std::vector<int, A2>>;
+ using M3 = std::flat_map<int, int, C, std::vector<int, A2>, std::vector<int, A1>>;
+ static_assert(std::is_constructible_v<M1, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, const C&, const A2&>);
+ }
{
using C = test_less<int>;
auto m = std::flat_map<int, char*, C>(C(3));
@@ -54,10 +70,11 @@ int main(int, char**) {
assert(m.values().get_allocator() == A2(5));
}
{
+ // explicit(false)
using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
- std::flat_map<int, short, C, std::deque<int, A1>, std::deque<short, A2>> m = {C(4), A1(5)}; // implicit ctor
+ std::flat_map<int, short, C, std::deque<int, A1>, std::deque<short, A2>> m = {C(4), A1(5)};
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(4));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
index 70b99b33b8dbca..19b4b0faed354d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
@@ -15,6 +15,9 @@
// template<class Allocator>
// flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
// const Allocator& a);
+// template<class Alloc>
+// flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+// const key_compare& comp, const Alloc& a);
#include <algorithm>
#include <deque>
@@ -28,6 +31,7 @@
#include "test_allocator.h"
#include "test_iterators.h"
#include "test_macros.h"
+#include "../../../test_compare.h"
struct P {
int first;
@@ -40,12 +44,41 @@ struct P {
int main(int, char**) {
{
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ static_assert(std::is_constructible_v<M1, const V1&, const V1&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, const V1&, const V1&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, const V1&, const V2&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, const V2&, const V1&, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, const V1&, const V1&, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, const V1&, const V1&, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, const V1&, const V2&, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, const V2&, const V1&, const C&, const A2&>);
+ }
+ {
+ // flat_map(key_container_type , mapped_container_type)
using M = std::flat_map<int, char>;
std::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
std::vector<char> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
auto m = M(ks, vs);
assert((m.keys() == std::vector<int>{1, 2, 3}));
LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
+
+ // explicit(false)
+ M m2 = {ks, vs};
+ assert(m2 == m);
+
m = M(std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
@@ -53,6 +86,8 @@ int main(int, char**) {
LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
}
{
+ // flat_map(key_container_type , mapped_container_type)
+ // move-only
P expected[] = {{3, 2}, {2, 1}, {1, 3}};
using Ks = std::deque<int, min_allocator<int>>;
using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
@@ -68,6 +103,8 @@ int main(int, char**) {
assert(std::ranges::equal(m, expected, std::equal_to<>()));
}
{
+ // flat_map(key_container_type , mapped_container_type)
+ // container's allocators are used
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
@@ -80,6 +117,23 @@ int main(int, char**) {
assert(m.values().get_allocator() == A(6));
}
{
+ // flat_map(key_container_type , mapped_container_type, key_compare)
+ using C = test_less<int>;
+ using M = std::flat_map<int, char, C>;
+ std::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::vector<char> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ auto m = M(ks, vs, C(4));
+ assert((m.keys() == std::vector<int>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
+ assert(m.key_comp() == C(4));
+
+ // explicit(false)
+ M m2 = {ks, vs, C(4)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(4));
+ }
+ {
+ // flat_map(key_container_type , mapped_container_type, const Allocator&)
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
@@ -92,6 +146,8 @@ int main(int, char**) {
assert(m.values().get_allocator() == A(4));
}
{
+ // flat_map(key_container_type , mapped_container_type, const Allocator&)
+ // explicit(false)
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
@@ -104,6 +160,28 @@ int main(int, char**) {
assert(m.values().get_allocator() == A(4));
}
{
+ // flat_map(key_container_type , mapped_container_type, key_compare, const Allocator&)
+ using C = test_less<int>;
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::vector<int, A>>;
+ std::vector<int, A> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::vector<int, A> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ auto m = M(ks, vs, C(4), A(5));
+ assert((m.keys() == std::vector<int, A>{1, 2, 3}));
+ LIBCPP_ASSERT((m.values() == std::vector<int, A>{1, 4, 6}));
+ assert(m.key_comp() == C(4));
+ assert(m.keys().get_allocator() == A(5));
+ assert(m.values().get_allocator() == A(5));
+
+ // explicit(false)
+ M m2 = {ks, vs, C(4), A(5)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(4));
+ assert(m2.keys().get_allocator() == A(5));
+ assert(m2.values().get_allocator() == A(5));
+ }
+ {
+ // pmr
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
@@ -119,6 +197,7 @@ int main(int, char**) {
assert(vm[0].values().get_allocator().resource() == &mr);
}
{
+ // pmr move
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
index 8841571d6b112b..c5b94896b92931 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp
@@ -35,6 +35,7 @@ int main(int, char**) {
assert(m.empty());
}
{
+ // explicit(false)
std::flat_map<int, char*> m = {};
assert(m.empty());
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
index 5f0b3be63ca70c..4ea1541b8e2f89 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -14,6 +14,8 @@
// flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare());
// template<class InputIterator, class Allocator>
// flat_map(InputIterator first, InputIterator last, const Allocator& a);
+// template<class InputIterator, class Allocator>
+// flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
#include <algorithm>
#include <deque>
@@ -26,30 +28,82 @@
#include "test_allocator.h"
#include "test_iterators.h"
#include "test_macros.h"
+#include "../../../test_compare.h"
int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ using Iter1 = typename M1::iterator;
+ using Iter2 = typename M2::iterator;
+ using Iter3 = typename M3::iterator;
+ static_assert(std::is_constructible_v<M1, Iter1, Iter1, const A1&>);
+ static_assert(!std::is_constructible_v<M1, Iter1, Iter1, const A2&>);
+ static_assert(!std::is_constructible_v<M2, Iter2, Iter2, const A2&>);
+ static_assert(!std::is_constructible_v<M3, Iter3, Iter3, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, Iter1, Iter1, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, Iter1, Iter1, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, Iter2, Iter2, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, Iter3, Iter3, const C&, const A2&>);
+ }
+
using P = std::pair<int, short>;
P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
P expected[] = {{1, 1}, {2, 4}, {3, 6}};
{
+ // flat_map(InputIterator , InputIterator)
+ // cpp17_input_iterator
using M = std::flat_map<int, short>;
auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
LIBCPP_ASSERT(std::ranges::equal(m, expected));
+
+ // explicit(false)
+ M m2 = {cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9)};
+ assert(m2 == m);
}
{
+ // flat_map(InputIterator , InputIterator)
+ // greater
using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<short>>;
auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
assert((m.keys() == std::deque<int, min_allocator<int>>{3, 2, 1}));
LIBCPP_ASSERT((m.values() == std::deque<short>{6, 4, 1}));
}
{
+ // flat_map(InputIterator , InputIterator)
// Test when the operands are of array type (also contiguous iterator type)
using M = std::flat_map<int, short, std::greater<int>, std::vector<int, min_allocator<int>>>;
auto m = M(ar, ar);
assert(m.empty());
}
{
+ // flat_map(InputIterator , InputIterator, const key_compare&)
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C, std::vector<int>, std::deque<short>>;
+ auto m = M(ar, ar + 9, C(3));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp() == C(3));
+
+ // explicit(false)
+ M m2 = {ar, ar + 9, C(3)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(3));
+ }
+ {
+ // flat_map(InputIterator , InputIterator, const Allocator&)
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
@@ -60,6 +114,8 @@ int main(int, char**) {
assert(m.values().get_allocator() == A2(5));
}
{
+ // flat_map(InputIterator , InputIterator, const Allocator&)
+ // explicit(false)
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
@@ -70,6 +126,32 @@ int main(int, char**) {
assert(m.values().get_allocator() == A2(5));
}
{
+ // flat_map(InputIterator , InputIterator, const key_compare&, const Allocator&)
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(ar, ar + 9, C(3), A1(5));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp() == C(3));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(InputIterator , InputIterator, const key_compare&, const Allocator&)
+ // explicit(false)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
+ M m = {ar, ar + 9, {}, A2(5)}; // implicit ctor
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // pmr cpp17 iterator
using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
@@ -80,6 +162,7 @@ int main(int, char**) {
assert(vm[0].values().get_allocator().resource() == &mr);
}
{
+ // pmr
using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
deleted file mode 100644
index d18994082eb98f..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter_comp.pass.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template <class InputIterator>
-// flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare());
-// template<class InputIterator, class Allocator>
-// flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
-
-#include <algorithm>
-#include <deque>
-#include <flat_map>
-#include <functional>
-#include <memory_resource>
-#include <vector>
-
-#include "min_allocator.h"
-#include "test_allocator.h"
-#include "test_iterators.h"
-#include "test_macros.h"
-#include "../../../test_compare.h"
-
-int main(int, char**) {
- using P = std::pair<int, short>;
- P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
- P expected[] = {{1, 1}, {2, 4}, {3, 6}};
- {
- using M = std::flat_map<int, short, std::function<bool(int, int)>>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::less<int>());
- assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
- assert(m.key_comp()(1, 2) == true);
- }
- {
- using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
- auto m = M(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), std::greater<int>());
- assert(std::ranges::equal(m.keys(), expected | std::views::reverse | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected | std::views::reverse));
- }
- {
- // Test when the operands are of array type (also contiguous iterator type)
- using C = test_less<int>;
- using M = std::flat_map<int, short, C, std::vector<int, min_allocator<int>>>;
- auto m = M(ar, ar, C(5));
- assert(m.empty());
- assert(m.key_comp() == C(5));
- }
- {
- using C = test_less<int>;
- using A1 = test_allocator<int>;
- using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
- auto m = M(ar, ar + 9, C(3), A1(5));
- assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
- assert(m.key_comp() == C(3));
- assert(m.keys().get_allocator() == A1(5));
- assert(m.values().get_allocator() == A2(5));
- }
- {
- using A1 = test_allocator<int>;
- using A2 = test_allocator<short>;
- using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
- M m = {ar, ar + 9, {}, A2(5)}; // implicit ctor
- assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
- assert(m.keys().get_allocator() == A1(5));
- assert(m.values().get_allocator() == A2(5));
- }
- {
- using C = test_less<int>;
- using M = std::flat_map<int, short, C, std::pmr::vector<int>, std::pmr::deque<short>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9), C(3));
- assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
- assert(vm[0].key_comp() == C(3));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using C = test_less<int>;
- using M = std::flat_map<int, short, C, std::pmr::vector<int>, std::pmr::vector<short>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(ar, ar, C(4));
- assert(vm[0].empty());
- assert(vm[0].key_comp() == C(4));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
new file mode 100644
index 00000000000000..b597f15c8bda88
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
@@ -0,0 +1,218 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<container-compatible-range<value_type> R>
+// flat_map(from_range_t, R&&)
+// template<container-compatible-range<value_type> R>
+// flat_map(from_range_t, R&&, const key_compare&)
+// template<container-compatible-range<value_type> R, class Alloc>
+// flat_map(from_range_t, R&&, const Alloc&);
+// template<container-compatible-range<value_type> R, class Alloc>
+// flat_map(from_range_t, R&&, const key_compare&, const Alloc&);
+
+#include <algorithm>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <string>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../../../test_compare.h"
+
+int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const C&, const A2&>);
+ }
+ {
+ // container-compatible-range
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<std::string>;
+ using M = std::flat_map<int, std::string, C, std::vector<int, A1>, std::vector<std::string, A2>>;
+ using Pair = std::pair<int, std::string>;
+ using PairLike = std::tuple<int, std::string>;
+ using NonPairLike = int;
+
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&>);
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&>);
+ static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&>);
+
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&>);
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&>);
+ static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&>);
+
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const A1&>);
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const A1&>);
+ static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const A1&>);
+
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&, const A1&>);
+ static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&, const A1&>);
+ }
+
+ using P = std::pair<int, short>;
+ P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
+ P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+ {
+ // flat_map(from_range_t, R&&)
+ // input_range && !common
+ using M = std::flat_map<int, short>;
+ using Iter = cpp20_input_iterator<const P*>;
+ using Sent = sentinel_wrapper<Iter>;
+ using R = std::ranges::subrange<Iter, Sent>;
+ auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+
+ // explicit(false)
+ M m2 = {std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))};
+ assert(m2 == m);
+ }
+ {
+ // flat_map(from_range_t, R&&)
+ // greater
+ using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>, std::deque<short>>;
+ using Iter = cpp20_input_iterator<const P*>;
+ using Sent = sentinel_wrapper<Iter>;
+ using R = std::ranges::subrange<Iter, Sent>;
+ auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));
+ assert((m.keys() == std::deque<int, min_allocator<int>>{3, 2, 1}));
+ LIBCPP_ASSERT((m.values() == std::deque<short>{6, 4, 1}));
+ }
+ {
+ // flat_map(from_range_t, R&&)
+ // contiguous range
+ using M = std::flat_map<int, short>;
+ using R = std::ranges::subrange<const P*>;
+ auto m = M(std::from_range, R(ar, ar + 9));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ }
+ {
+ // flat_map(from_range_t, R&&, const key_compare&)
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C, std::vector<int>, std::deque<short>>;
+ using R = std::ranges::subrange<const P*>;
+ auto m = M(std::from_range, R(ar, ar + 9), C(3));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp() == C(3));
+
+ // explicit(false)
+ M m2 = {std::from_range, R(ar, ar + 9), C(3)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(3));
+ }
+ {
+ // flat_map(from_range_t, R&&, const Allocator&)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ using R = std::ranges::subrange<const P*>;
+ auto m = M(std::from_range, R(ar, ar + 9), A1(5));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(from_range_t, R&&, const Allocator&)
+ // explicit(false)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ using R = std::ranges::subrange<const P*>;
+ M m = {std::from_range, R(ar, ar + 9), A1(5)}; // implicit ctor
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(from_range_t, R&&, const key_compare&, const Allocator&)
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ using R = std::ranges::subrange<const P*>;
+ auto m = M(std::from_range, R(ar, ar + 9), C(3), A1(5));
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.key_comp() == C(3));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(from_range_t, R&&, const key_compare&, const Allocator&)
+ // explicit(false)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::deque<int, A1>, std::vector<short, A2>>;
+ using R = std::ranges::subrange<const P*>;
+ M m = {std::from_range, R(ar, ar + 9), {}, A2(5)}; // implicit ctor
+ assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(m, expected));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // pmr input_range
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ using Iter = cpp20_input_iterator<const P*>;
+ using Sent = sentinel_wrapper<Iter>;
+ using R = std::ranges::subrange<Iter, Sent>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));
+ assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // pmr
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ using R = std::ranges::subrange<const P*>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::from_range, R(ar, ar));
+ assert(vm[0].empty());
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index eeb536f5277653..23bc612381d51e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -12,6 +12,14 @@
// flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
// const key_compare& comp = key_compare());
+//
+// template<class Alloc>
+// flat_map(sorted_unique_t, const key_container_type& key_cont,
+// const mapped_container_type& mapped_cont, const Alloc& a);
+// template<class Alloc>
+// flat_map(sorted_unique_t, const key_container_type& key_cont,
+// const mapped_container_type& mapped_cont,
+// const key_compare& comp, const Alloc& a);
#include <deque>
#include <flat_map>
@@ -24,20 +32,54 @@
#include "test_allocator.h"
#include "test_iterators.h"
#include "test_macros.h"
+#include "../../../test_compare.h"
int main(int, char**) {
{
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, const V1&, const V1&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, const V1&, const V1&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, const V1&, const V2&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, const V2&, const V1&, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, const V1&, const V1&, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, const V1&, const V1&, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, const V1&, const V2&, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, const V2&, const V1&, const C&, const A2&>);
+ }
+ {
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type)
using M = std::flat_map<int, char>;
std::vector<int> ks = {1, 2, 4, 10};
std::vector<char> vs = {4, 3, 2, 1};
- auto m = M(std::sorted_unique, ks, vs);
+ auto ks2 = ks;
+ auto vs2 = vs;
+
+ auto m = M(std::sorted_unique, ks, vs);
assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
m = M(std::sorted_unique, std::move(ks), std::move(vs));
assert(ks.empty()); // it was moved-from
assert(vs.empty()); // it was moved-from
assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, std::move(ks2), std::move(vs2)};
+ assert(m == m2);
}
{
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type)
+ // non-default container, comparator and allocator type
using Ks = std::deque<int, min_allocator<int>>;
using Vs = std::deque<char, min_allocator<char>>;
using M = std::flat_map<int, char, std::greater<int>, Ks, Vs>;
@@ -51,6 +93,8 @@ int main(int, char**) {
assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
}
{
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type)
+ // allocator copied into the containers
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
auto ks = std::vector<int, A>({1, 2, 4, 10}, A(4));
@@ -63,6 +107,43 @@ int main(int, char**) {
assert(m.values().get_allocator() == A(5));
}
{
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type, key_compare)
+ using C = test_less<int>;
+ using M = std::flat_map<int, char, C>;
+ std::vector<int> ks = {1, 2, 4, 10};
+ std::vector<char> vs = {4, 3, 2, 1};
+
+ auto m = M(std::sorted_unique, ks, vs, C(4));
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+ assert(m.key_comp() == C(4));
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, ks, vs, C(4)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(4));
+ }
+ {
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type, key_compare, const Allocator&)
+ using C = test_less<int>;
+ using A = test_allocator<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, A>, std::vector<int, A>>;
+ std::vector<int, A> ks = {1, 2, 4, 10};
+ std::vector<int, A> vs = {4, 3, 2, 1};
+ auto m = M(std::sorted_unique, ks, vs, C(4), A(5));
+ assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+ assert(m.key_comp() == C(4));
+ assert(m.keys().get_allocator() == A(5));
+ assert(m.values().get_allocator() == A(5));
+
+ // explicit(false)
+ M m2 = {ks, vs, C(4), A(5)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(4));
+ assert(m2.keys().get_allocator() == A(5));
+ assert(m2.values().get_allocator() == A(5));
+ }
+ {
+ // flat_map(sorted_unique_t, key_container_type , mapped_container_type, const Allocator&)
using A = test_allocator<int>;
using M = std::flat_map<int, int, std::less<int>, std::vector<int, A>, std::deque<int, A>>;
auto ks = std::vector<int, A>({1, 2, 4, 10}, A(4));
@@ -73,8 +154,15 @@ int main(int, char**) {
assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(m.keys().get_allocator() == A(6));
assert(m.values().get_allocator() == A(6));
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, ks, vs, A(6)};
+ assert(m2 == m);
+ assert(m2.keys().get_allocator() == A(6));
+ assert(m2.values().get_allocator() == A(6));
}
{
+ // pmr
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
@@ -88,6 +176,7 @@ int main(int, char**) {
assert(vm[0].values().get_allocator().resource() == &mr);
}
{
+ // pmr move
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
similarity index 50%
rename from libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
index 3eebfc2d099160..0ad71ca8b8e992 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
@@ -12,6 +12,8 @@
// template <class InputIterator>
// flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare());
+// template<class InputIterator, class Alloc>
+// flat_map(InputIterator first, InputIterator last, const Alloc& a);
// template<class InputIterator, class Allocator>
// flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
@@ -29,6 +31,57 @@
int main(int, char**) {
{
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ using Iter1 = typename M1::iterator;
+ using Iter2 = typename M2::iterator;
+ using Iter3 = typename M3::iterator;
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, Iter1, Iter1, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, Iter1, Iter1, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, Iter2, Iter2, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, Iter3, Iter3, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, Iter1, Iter1, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, Iter1, Iter1, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, Iter2, Iter2, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, Iter3, Iter3, const C&, const A2&>);
+ }
+ {
+ // flat_map(sorted_unique_t, InputIterator, InputIterator);
+ // cpp17_input_iterator
+ using M = std::flat_map<int, int>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ auto m = M(std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4));
+ auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ assert(m == expected);
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4)};
+ assert(m2 == m);
+ }
+ {
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&);
+ // contiguous iterator
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
+ std::pair<int, int> ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ auto m = M(std::sorted_unique, ar, ar + 4);
+ auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ assert(m == expected);
+ }
+ {
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&);
+ // cpp_17_input_iterator
using M = std::flat_map<int, int, std::function<bool(int, int)>>;
using P = std::pair<int, int>;
P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
@@ -38,8 +91,17 @@ int main(int, char**) {
std::less<int>());
assert(m == M({{1, 1}, {2, 2}, {4, 4}, {5, 5}}, std::less<>()));
assert(m.key_comp()(1, 2) == true);
+
+ // explicit(false)
+ M m2 = {std::sorted_unique,
+ cpp17_input_iterator<const P*>(ar),
+ cpp17_input_iterator<const P*>(ar + 4),
+ std::less<int>()};
+ assert(m2 == m);
}
{
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&);
+ // greater
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int>>;
using P = std::pair<int, int>;
P ar[] = {{5, 5}, {4, 4}, {2, 2}, {1, 1}};
@@ -50,7 +112,8 @@ int main(int, char**) {
assert((m == M{{5, 5}, {4, 4}, {2, 2}, {1, 1}}));
}
{
- // Test when the operands are of array type (also contiguous iterator type)
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&);
+ // contiguous iterator
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
std::pair<int, int> ar[1] = {{42, 42}};
@@ -59,6 +122,26 @@ int main(int, char**) {
assert(m.key_comp() == C(5));
}
{
+ // flat_map(sorted_unique_t, InputIterator , InputIterator, const Allocator&)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ auto m = M(std::sorted_unique, ar, ar + 4, A1(5));
+ auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ assert(m == expected);
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, ar, ar + 4, A1(5)};
+ assert(m2 == m);
+ assert(m2.keys().get_allocator() == A1(5));
+ assert(m2.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&, const Allocator&);
using C = test_less<int>;
using A1 = test_allocator<int>;
using A2 = test_allocator<short>;
@@ -72,6 +155,8 @@ int main(int, char**) {
assert(m.values().get_allocator() == A2(5));
}
{
+ // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&, const Allocator&);
+ // explicit(false)
using A1 = test_allocator<short>;
using A2 = test_allocator<int>;
using M = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
@@ -83,6 +168,7 @@ int main(int, char**) {
assert(m.values().get_allocator() == A2(5));
}
{
+ // pmr cpp_17
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
@@ -97,6 +183,7 @@ int main(int, char**) {
assert(vm[0].values().get_allocator().resource() == &mr);
}
{
+ // pmr
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp
new file mode 100644
index 00000000000000..ecce6534fd57b3
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// using key_type = Key;
+// using mapped_type = T;
+// using value_type = pair<key_type, mapped_type>;
+// using key_compare = Compare;
+// using reference = pair<const key_type&, mapped_type&>;
+// using const_reference = pair<const key_type&, const mapped_type&>;
+// using size_type = size_t;
+// using difference_type = ptrdiff_t;
+// using iterator = implementation-defined; // see [container.requirements]
+// using const_iterator = implementation-defined; // see [container.requirements]
+// using reverse_iterator = std::reverse_iterator<iterator>;
+// using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+// using key_container_type = KeyContainer;
+// using mapped_container_type = MappedContainer;
+
+// class value_compare;
+
+// struct containers {
+// key_container_type keys;
+// mapped_container_type values;
+// };
+
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <ranges>
+#include <string>
+#include <vector>
+
+void test() {
+ {
+ using M = std::flat_map<int, double>;
+ static_assert(std::is_same_v<typename M::key_type, int>);
+ static_assert(std::is_same_v<typename M::mapped_type, double>);
+ static_assert(std::is_same_v<typename M::value_type, std::pair<int, double>>);
+ static_assert(std::is_same_v<typename M::key_compare, std::less<int>>);
+ static_assert(std::is_same_v<typename M::reference, std::pair<const int&, double&>>);
+ static_assert(std::is_same_v<typename M::const_reference, std::pair<const int&, const double&>>);
+ static_assert(std::is_same_v<typename M::size_type, size_t>);
+ static_assert(std::is_same_v<typename M::difference_type, ptrdiff_t>);
+ static_assert(requires { typename M::iterator; });
+ static_assert(requires { typename M::const_iterator; });
+ static_assert(std::is_same_v<typename M::reverse_iterator, std::reverse_iterator<typename M::iterator>>);
+ static_assert(
+ std::is_same_v<typename M::const_reverse_iterator, std::reverse_iterator<typename M::const_iterator>>);
+ static_assert(std::is_same_v<typename M::key_container_type, std::vector<int>>);
+ static_assert(std::is_same_v<typename M::mapped_container_type, std::vector<double>>);
+ static_assert(requires { typename M::value_compare; });
+ static_assert(requires { typename M::containers; });
+ static_assert(std::is_same_v<decltype(M::containers::keys), std::vector<int>>);
+ static_assert(std::is_same_v<decltype(M::containers::values), std::vector<double>>);
+ }
+
+ {
+ struct A {};
+ struct Compare {
+ bool operator()(const std::string&, const std::string&) const;
+ };
+ using M = std::flat_map<std::string, A, Compare, std::deque<std::string>, std::deque<A>>;
+ static_assert(std::is_same_v<typename M::key_type, std::string>);
+ static_assert(std::is_same_v<typename M::mapped_type, A>);
+ static_assert(std::is_same_v<typename M::value_type, std::pair<std::string, A>>);
+ static_assert(std::is_same_v<typename M::key_compare, Compare>);
+ static_assert(std::is_same_v<typename M::reference, std::pair<const std::string&, A&>>);
+ static_assert(std::is_same_v<typename M::const_reference, std::pair<const std::string&, const A&>>);
+ static_assert(std::is_same_v<typename M::size_type, size_t>);
+ static_assert(std::is_same_v<typename M::difference_type, ptrdiff_t>);
+ static_assert(requires { typename M::iterator; });
+ static_assert(requires { typename M::const_iterator; });
+ static_assert(std::is_same_v<typename M::reverse_iterator, std::reverse_iterator<typename M::iterator>>);
+ static_assert(
+ std::is_same_v<typename M::const_reverse_iterator, std::reverse_iterator<typename M::const_iterator>>);
+ static_assert(std::is_same_v<typename M::key_container_type, std::deque<std::string>>);
+ static_assert(std::is_same_v<typename M::mapped_container_type, std::deque<A>>);
+ static_assert(requires { typename M::value_compare; });
+ static_assert(requires { typename M::containers; });
+ static_assert(std::is_same_v<decltype(M::containers::keys), std::deque<std::string>>);
+ static_assert(std::is_same_v<decltype(M::containers::values), std::deque<A>>);
+ }
+}
>From 3bbead67b955f770429bdccbbb6b338e1b658b7a Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 20 Sep 2024 17:55:01 +0100
Subject: [PATCH 16/40] lots of fixes
---
libcxx/include/__flat_map/flat_map.h | 73 ++++--
libcxx/include/__memory/allocator_traits.h | 3 -
.../flat.map/assert.sorted_unique.pass.cpp | 9 +
.../flat.map/contains_transparent.pass.cpp | 38 ---
.../flat.map/find_transparent.pass.cpp | 41 ---
.../flat.map/flat.map.access/at.pass.cpp | 132 ++++++++++
.../flat.map.access/at_transparent.pass.cpp | 143 ++++++++++
.../flat.map.access/index_key.pass.cpp | 95 +++++++
.../flat.map.access/index_rv_key.pass.cpp | 69 +++++
.../index_transparent.pass.cpp | 114 ++++++++
.../{ => flat.map.capacity}/empty.pass.cpp | 0
.../{ => flat.map.capacity}/empty.verify.cpp | 0
.../{ => flat.map.capacity}/max_size.pass.cpp | 0
.../flat.map/flat.map.capacity/size.pass.cpp | 31 +++
.../flat.map/flat.map.cons/alloc.pass.cpp | 33 +++
.../flat.map/flat.map.cons/compare.pass.cpp | 2 +-
.../flat.map.cons/containers.pass.cpp | 2 +-
.../flat.map.cons/containers_compare.pass.cpp | 245 ------------------
.../flat.map.cons/copy_alloc.pass.cpp | 19 ++
.../flat.map/flat.map.cons/deduct.pass.cpp | 6 +-
.../flat.map.cons/initializer_list.pass.cpp | 123 ++++++++-
.../initializer_list_compare.pass.cpp | 80 ------
.../flat.map/flat.map.cons/iter_iter.pass.cpp | 2 +-
.../flat.map.cons/move_alloc.pass.cpp | 19 ++
.../flat.map/flat.map.cons/range.pass.cpp | 36 ++-
.../flat.map.cons/sorted_container.pass.cpp | 2 +-
.../sorted_initializer_list.pass.cpp | 207 +++++++++++++++
.../flat.map.cons/sorted_iter_iter.pass.cpp | 2 +-
.../iterator.pass.cpp | 26 +-
.../iterator_comparison.pass.cpp | 0
...rator_concept_conformance.compile.pass.cpp | 0
...range_concept_conformance.compile.pass.cpp | 0
.../reverse_iterator.pass.cpp | 25 +-
.../{ => flat.map.modifiers}/clear.pass.cpp | 0
.../flat.map.modifiers/emplace.pass.cpp | 123 +++++++++
.../flat.map.modifiers/emplace_hint.pass.cpp | 117 +++++++++
.../erase_key.pass.cpp | 0
.../erase_key_transparent.pass.cpp | 12 +-
.../{ => flat.map.modifiers}/extract.pass.cpp | 2 +-
.../flat.map.modifiers/insert_cv.pass.cpp | 75 ++++++
.../insert_initializer_list.pass.cpp | 77 ++++++
.../insert_iter_cv.pass.cpp | 72 +++++
.../insert_iter_iter.pass.cpp | 93 +++++++
.../insert_iter_rv.pass.cpp | 98 +++++++
.../insert_range.pass.cpp | 11 +
.../insert_range_stability.pass.cpp | 0
.../flat.map.modifiers/insert_rv.pass.cpp | 110 ++++++++
.../insert_sorted_initializer_list.pass.cpp | 68 +++++
.../insert_sorted_iter_iter.pass.cpp | 91 +++++++
.../insert_transparent.pass.cpp | 15 ++
.../{ => flat.map.observers}/comp.pass.cpp | 0
.../contains.pass.cpp | 0
.../contains_transparent.pass.cpp | 65 +++++
.../{ => flat.map.operations}/count.pass.cpp | 0
.../count_transparent.pass.cpp | 12 +-
.../equal_range.pass.cpp | 0
.../equal_range_transparent.pass.cpp | 12 +-
.../{ => flat.map.operations}/find.pass.cpp | 0
.../find_transparent.pass.cpp | 83 ++++++
.../lower_bound.pass.cpp | 0
.../lower_bound_transparent.pass.cpp | 88 +++++++
.../upper_bound.pass.cpp | 0
.../upper_bound_transparent.pass.cpp | 88 +++++++
.../container.adaptors/flat.map/helpers.h | 40 ++-
.../flat.map/lower_bound_transparent.pass.cpp | 39 ---
...ompile.pass.cpp => types.compile.pass.cpp} | 42 +++
.../flat.map/types.pass.cpp | 85 ------
.../flat.map/upper_bound_transparent.pass.cpp | 39 ---
68 files changed, 2494 insertions(+), 640 deletions(-)
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.capacity}/empty.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.capacity}/empty.verify.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.capacity}/max_size.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.iterators}/iterator.pass.cpp (77%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.iterators}/iterator_comparison.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.iterators}/iterator_concept_conformance.compile.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.iterators}/range_concept_conformance.compile.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.iterators}/reverse_iterator.pass.cpp (79%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/clear.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/erase_key.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/erase_key_transparent.pass.cpp (89%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/extract.pass.cpp (98%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/insert_range.pass.cpp (87%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/insert_range_stability.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.modifiers}/insert_transparent.pass.cpp (90%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.observers}/comp.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/contains.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/count.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/count_transparent.pass.cpp (79%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/equal_range.pass.cpp (100%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/equal_range_transparent.pass.cpp (85%)
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/find.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/lower_bound.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{ => flat.map.operations}/upper_bound.pass.cpp (100%)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
rename libcxx/test/std/containers/container.adaptors/flat.map/{typedef.compile.pass.cpp => types.compile.pass.cpp} (63%)
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index e05a7b8f925a3e..e0451e4a9a8223 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -79,7 +79,7 @@ class flat_map {
using key_type = _Key;
using mapped_type = _Tp;
using value_type = pair<key_type, mapped_type>;
- using key_compare = _Compare;
+ using key_compare = __type_identity_t<_Compare>;
// TODO : the following is the spec, but not implementable for vector<bool>
// using reference = pair<const key_type&, mapped_type&>;
// using const_reference = pair<const key_type&, const mapped_type&>;
@@ -523,12 +523,21 @@ class flat_map {
}
// [flat.map.access], element access
- _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __x) { return try_emplace(__x).first->second; }
+ _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __x)
+ requires is_constructible_v<mapped_type>
+ {
+ return try_emplace(__x).first->second;
+ }
- _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __x) { return try_emplace(std::move(__x)).first->second; }
+ _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __x)
+ requires is_constructible_v<mapped_type>
+ {
+ return try_emplace(std::move(__x)).first->second;
+ }
template <class _Kp>
- requires __is_compare_transparent
+ requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type> &&
+ is_convertible_v<_Kp&&, const_iterator> && is_convertible_v<_Kp&&, iterator>
_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](_Kp&& __x) {
return try_emplace(std::forward<_Kp>(__x)).first->second;
}
@@ -574,6 +583,8 @@ class flat_map {
// [flat.map.modifiers], modifiers
template <class... _Args>
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
+ // todo: LWG
+ // insufficiently constrained. key and values need to be move constructible
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
return __try_emplace(std::move(__pair.first), std::move(__pair.second));
@@ -649,6 +660,11 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI void replace(key_container_type&& __key_cont, mapped_container_type&& __mapped_cont) {
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+ __key_cont.size() == __mapped_cont.size(), "flat_map keys and mapped containers have different size");
+
+ _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+ __is_sorted_and_unique(__key_cont), "Either the key container is not sorted or it contains duplicates");
auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
__containers_.keys = std::move(__key_cont);
__containers_.values = std::move(__mapped_cont);
@@ -817,6 +833,8 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
template <class _Kp>
+ // todo: spec does not say about transparent for this one. LWG issue?
+ requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const {
return find(__x) != end();
}
@@ -854,7 +872,7 @@ class flat_map {
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const {
- return __upper_bound<iterator>(*this, __x);
+ return __upper_bound<const_iterator>(*this, __x);
}
_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __x) {
@@ -1044,7 +1062,15 @@ class flat_map {
template <class _Kp>
_LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) {
- if (__hint != cbegin() && !__compare_(std::prev(__hint)->first, __key)) {
+ // todo
+ // note that we have very fragile std::prev in our library
+ // for non LegacyBidirectional iterator, std::prev(it) is well formed and a no-op
+ // here we cannot use std::prev because our iterator is not legacy bidirectional
+ // since its reference type is not a reference
+ // note that user can also attempt to use std::prev on the flat_map::iterator
+ // and it would result in a no-op.
+ // we should probably ban std::prev(LegacyInputIterator)
+ if (__hint != cbegin() && !__compare_((__hint - 1)->first, __key)) {
return false;
}
if (__hint != cend() && __compare_(__hint->first, __key)) {
@@ -1056,7 +1082,7 @@ class flat_map {
template <class _Kp, class... _Args>
_LIBCPP_HIDE_FROM_ABI iterator __try_emplace_hint(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
if (__is_hint_correct(__hint, __key)) {
- if (__compare_(__key, __hint->first)) {
+ if (__hint == cend() || __compare_(__key, __hint->first)) {
return __try_emplace_exact_hint(
__hint.__key_iter_, __hint.__mapped_iter_, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
} else {
@@ -1238,24 +1264,25 @@ flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
template <ranges::input_range _Range,
- class _Compare = less<__iter_key_type<_Range>>,
- class _Allocator = allocator<byte>>
- requires(!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value)
+ class _Compare = less<__range_key_type<_Range>>,
+ class _Allocator = allocator<byte>,
+ class = __enable_if_t<!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value>>
flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
- -> flat_map<__range_key_type<_Range>,
- __range_mapped_type<_Range>,
- _Compare,
- vector<__range_key_type<_Range>, __alloc_rebind<_Allocator, __range_key_type<_Range>>>,
- vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
-
-template <ranges::input_range _Range, class _Allocator>
- requires __is_allocator<_Allocator>::value
+ -> flat_map<
+ __range_key_type<_Range>,
+ __range_mapped_type<_Range>,
+ _Compare,
+ vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>,
+ vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
+
+template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator<_Allocator>::value>>
flat_map(from_range_t, _Range&&, _Allocator)
- -> flat_map<__range_key_type<_Range>,
- __range_mapped_type<_Range>,
- less<__range_key_type<_Range>>,
- vector<__range_key_type<_Range>, __alloc_rebind<_Allocator, __range_key_type<_Range>>>,
- vector<__range_mapped_type<_Range>, __alloc_rebind<_Allocator, __range_mapped_type<_Range>>>>;
+ -> flat_map<
+ __range_key_type<_Range>,
+ __range_mapped_type<_Range>,
+ less<__range_key_type<_Range>>,
+ vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>,
+ vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
template <class _Key, class _Tp, class _Compare = less<_Key>>
requires(!__is_allocator<_Compare>::value)
diff --git a/libcxx/include/__memory/allocator_traits.h b/libcxx/include/__memory/allocator_traits.h
index 3da2f0909fa99b..f4d9679807ae01 100644
--- a/libcxx/include/__memory/allocator_traits.h
+++ b/libcxx/include/__memory/allocator_traits.h
@@ -373,9 +373,6 @@ template <class _Traits, class _Tp>
using __rebind_alloc = typename _Traits::template rebind_alloc<_Tp>::other;
#endif
-template <class _Allocator, class _Tp>
-using __alloc_rebind = __rebind_alloc<allocator_traits<_Allocator>, _Tp>;
-
template <class _Alloc>
struct __check_valid_allocator : true_type {
using _Traits = std::allocator_traits<_Alloc>;
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
index c98998971bf022..0f4038bac35f80 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
@@ -206,5 +206,14 @@ int main(int, char**) {
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};
+ std::vector values{4, 5, 6};
+ M m;
+ m.replace(std::move(keys), std::move(values));
+ }()),
+ "Either the key container is not sorted or it contains duplicates");
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
deleted file mode 100644
index 672e9245884413..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/contains_transparent.pass.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template<class K> bool contains(const K& x) const;
-
-#include <cassert>
-#include <flat_map>
-#include <string>
-#include <utility>
-
-#include "helpers.h"
-#include "test_macros.h"
-
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.contains(StartsWith('b'))), bool);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(StartsWith('b'))), bool);
- assert(m.contains("beta") == true);
- assert(m.contains("delta") == false);
- assert(m.contains("zeta") == false);
- assert(m.contains(StartsWith('b')) == true);
- assert(m.contains(StartsWith('d')) == false);
- assert(m.contains(StartsWith('e')) == true);
- assert(m.contains(StartsWith('z')) == false);
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
deleted file mode 100644
index d190e6a3adc9cf..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/find_transparent.pass.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template<class K> iterator find(const K& x);
-// template<class K> const_iterator find(const K& x) const;
-
-#include <cassert>
-#include <flat_map>
-#include <string>
-#include <utility>
-
-#include "helpers.h"
-#include "test_macros.h"
-
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.find(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(StartsWith('b'))), M::const_iterator);
- assert(m.find("beta") == m.begin() + 1);
- assert(m.find("delta") == m.end());
- assert(m.find("zeta") == m.end());
- assert(m.find(StartsWith('b')) == m.begin() + 1);
- assert(m.find(StartsWith('d')) == m.end());
- auto it = m.find(StartsWith('e'));
- assert(m.begin() + 2 <= it && it <= m.begin() + 3); // either is acceptable
- LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
- assert(m.find(StartsWith('z')) == m.end());
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
new file mode 100644
index 00000000000000..97cb64de8e4d7a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// mapped_type& at(const key_type& k);
+// const mapped_type& at(const key_type& k) const;
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <stdexcept>
+
+#include "min_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ const int one = 1;
+ {
+ std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
+ assert(m.size() == 7);
+ assert(m.at(one) == 1.5);
+ m.at(1) = -1.5;
+ assert(m.at(1) == -1.5);
+ assert(m.at(2) == 2.5);
+ assert(m.at(3) == 3.5);
+ assert(m.at(4) == 4.5);
+ assert(m.at(5) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(6);
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(7) == 7.5);
+ assert(m.at(8) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ const std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
+ assert(m.size() == 7);
+ assert(m.at(one) == 1.5);
+ assert(m.at(2) == 2.5);
+ assert(m.at(3) == 3.5);
+ assert(m.at(4) == 4.5);
+ assert(m.at(5) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(6);
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(7) == 7.5);
+ assert(m.at(8) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>
+ m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
+ assert(m.size() == 7);
+ assert(m.at(one) == 1.5);
+ m.at(1) = -1.5;
+ assert(m.at(1) == -1.5);
+ assert(m.at(2) == 2.5);
+ assert(m.at(3) == 3.5);
+ assert(m.at(4) == 4.5);
+ assert(m.at(5) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(6);
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(7) == 7.5);
+ assert(m.at(8) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ const std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>
+ m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
+ assert(m.size() == 7);
+ assert(m.at(1) == 1.5);
+ assert(m.at(2) == 2.5);
+ assert(m.at(3) == 3.5);
+ assert(m.at(4) == 4.5);
+ assert(m.at(5) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(6);
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(7) == 7.5);
+ assert(m.at(8) == 8.5);
+ assert(m.size() == 7);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
new file mode 100644
index 00000000000000..32477bb25a4976
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
@@ -0,0 +1,143 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> mapped_type& at(const K& x);
+// template<class K> const mapped_type& at(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <stdexcept>
+
+#include "../helpers.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanAt = requires(M m, Transparent<int> k) { m.at(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanAt<TransparentMap>);
+static_assert(CanAt<const TransparentMap>);
+static_assert(!CanAt<NonTransparentMap>);
+static_assert(!CanAt<const NonTransparentMap>);
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ const Transparent<int> one{1};
+ {
+ std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
+ assert(m.size() == 7);
+ assert(m.at(one) == 1.5);
+ m.at(one) = -1.5;
+ assert(m.at(Transparent<int>{1}) == -1.5);
+ assert(m.at(Transparent<int>{2}) == 2.5);
+ assert(m.at(Transparent<int>{3}) == 3.5);
+ assert(m.at(Transparent<int>{4}) == 4.5);
+ assert(m.at(Transparent<int>{5}) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(Transparent<int>{7}) == 7.5);
+ assert(m.at(Transparent<int>{8}) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ const std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
+ assert(m.size() == 7);
+ assert(m.at(Transparent<int>{1}) == 1.5);
+ assert(m.at(Transparent<int>{2}) == 2.5);
+ assert(m.at(Transparent<int>{3}) == 3.5);
+ assert(m.at(Transparent<int>{4}) == 4.5);
+ assert(m.at(Transparent<int>{5}) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(Transparent<int>{7}) == 7.5);
+ assert(m.at(Transparent<int>{8}) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ std::flat_map<int,
+ double,
+ TransparentComparator,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>
+ m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
+ assert(m.size() == 7);
+ assert(m.at(one) == 1.5);
+ m.at(one) = -1.5;
+ assert(m.at(Transparent<int>{1}) == -1.5);
+ assert(m.at(Transparent<int>{2}) == 2.5);
+ assert(m.at(Transparent<int>{3}) == 3.5);
+ assert(m.at(Transparent<int>{4}) == 4.5);
+ assert(m.at(Transparent<int>{5}) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(Transparent<int>{7}) == 7.5);
+ assert(m.at(Transparent<int>{8}) == 8.5);
+ assert(m.size() == 7);
+ }
+ {
+ const std::flat_map<int,
+ double,
+ TransparentComparator,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>
+ m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
+ assert(m.size() == 7);
+ assert(m.at(Transparent<int>{1}) == 1.5);
+ assert(m.at(Transparent<int>{2}) == 2.5);
+ assert(m.at(Transparent<int>{3}) == 3.5);
+ assert(m.at(Transparent<int>{4}) == 4.5);
+ assert(m.at(Transparent<int>{5}) == 5.5);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ try {
+ TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
+ assert(false);
+ } catch (std::out_of_range&) {
+ }
+#endif
+ assert(m.at(Transparent<int>{7}) == 7.5);
+ assert(m.at(Transparent<int>{8}) == 8.5);
+ assert(m.size() == 7);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
new file mode 100644
index 00000000000000..45625d00d495be
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// mapped_type& operator[](const key_type& k);
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+
+#include "../helpers.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+
+// Constraints: is_constructible_v<mapped_type> is true.
+template <class M, class Input>
+concept CanIndex = requires(M m, Input k) { m[k]; };
+
+static_assert(CanIndex<std::flat_map<int, double>, const int&>);
+static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, const int&>);
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ const int one = 1;
+ {
+ std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ assert(m.size() == 7);
+ assert(m[one] == 1.5);
+ assert(m.size() == 7);
+ m[1] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 7);
+ assert(m[6] == 0);
+ assert(m.size() == 8);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 8);
+ }
+ {
+ // allocator
+ using A1 = min_allocator<int>;
+ using A2 = min_allocator<double>;
+ using M = std::flat_map<int, double, std::less<int>, std::vector<int, A1>, std::vector<double, A2>>;
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ assert(m.size() == 7);
+ assert(m[1] == 1.5);
+ assert(m.size() == 7);
+ const int i = 1;
+ m[i] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 7);
+ assert(m[6] == 0);
+ assert(m.size() == 8);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 8);
+ }
+ {
+ std::flat_map<int, double, std::less<>> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+
+ assert(m.size() == 7);
+ assert(m[1] == 1.5);
+ assert(m.size() == 7);
+ m[1] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 7);
+ assert(m[6] == 0);
+ assert(m.size() == 8);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 8);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
new file mode 100644
index 00000000000000..a3d34feca752d2
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// mapped_type& operator[](key_type&& k);
+
+#include <flat_map>
+#include <functional>
+#include <cassert>
+
+#include "../helpers.h"
+#include "test_macros.h"
+#include "MoveOnly.h"
+#include "min_allocator.h"
+
+// Constraints: is_constructible_v<mapped_type> is true.
+template <class M, class Input>
+concept CanIndex = requires(M m, Input k) { m[k]; };
+
+static_assert(CanIndex<std::flat_map<int, double>, int&&>);
+static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, int&&>);
+
+int main(int, char**) {
+ {
+ std::flat_map<MoveOnly, double> m;
+ ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
+ assert(m.size() == 0);
+ assert(m[1] == 0.0);
+ assert(m.size() == 1);
+ m[1] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 1);
+ assert(m[6] == 0);
+ assert(m.size() == 2);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 2);
+ }
+ {
+ std::flat_map< MoveOnly,
+ double,
+ std::less<>,
+ std::vector<MoveOnly, min_allocator<MoveOnly>>,
+ std::vector<double, min_allocator<double>>>
+ m;
+ ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
+ assert(m.size() == 0);
+ assert(m[1] == 0.0);
+ assert(m.size() == 1);
+ m[1] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 1);
+ assert(m[6] == 0);
+ assert(m.size() == 2);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 2);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
new file mode 100644
index 00000000000000..fb37a175cacb48
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> mapped_type& operator[](K&& x);
+
+#include <cassert>
+#include <flat_map>
+#include <functional>
+
+#include "../helpers.h"
+#include "test_macros.h"
+#include "min_allocator.h"
+
+// Constraints:
+// The qualified-id Compare::is_transparent is valid and denotes a type.
+// is_constructible_v<key_type, K> is true.
+// is_constructible_v<mapped_type, Args...> is true.
+// is_convertible_v<K&&, const_iterator> and is_convertible_v<K&&, iterator> are both false
+template <class M, class Input>
+concept CanIndex = requires(M m, Input k) { m[k]; };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+using TransparentNoDefaultCtrValueMap = std::flat_map<int, NoDefaultCtr, TransparentComparator>;
+
+static_assert(CanIndex<TransparentMap, ConvertibleTransparent<int>>);
+static_assert(!CanIndex<const TransparentMap, ConvertibleTransparent<int>>);
+
+static_assert(!CanIndex<NonTransparentMap, NonConvertibleTransparent<int>>);
+static_assert(!CanIndex<const NonTransparentMap, NonConvertibleTransparent<int>>);
+
+static_assert(!CanIndex<TransparentMap, NonConvertibleTransparent<int>>);
+static_assert(!CanIndex<const TransparentMap, NonConvertibleTransparent<int>>);
+
+static_assert(!CanIndex<TransparentNoDefaultCtrValueMap, ConvertibleTransparent<int>>);
+static_assert(!CanIndex<const TransparentNoDefaultCtrValueMap, ConvertibleTransparent<int>>);
+
+static_assert(!CanIndex<TransparentMap, TransparentMap::iterator>);
+static_assert(!CanIndex<TransparentMap, TransparentMap::const_iterator>);
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ const ConvertibleTransparent<int> one{1};
+ const ConvertibleTransparent<int> six{6};
+ {
+ std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ assert(m.size() == 7);
+ assert(m[one] == 1.5);
+ assert(m.size() == 7);
+ m[one] = -1.5;
+ assert(m[one] == -1.5);
+ assert(m.size() == 7);
+ assert(m[six] == 0);
+ assert(m.size() == 8);
+ m[six] = 6.5;
+ assert(m[six] == 6.5);
+ assert(m.size() == 8);
+ }
+ {
+ // allocator
+ using A1 = min_allocator<int>;
+ using A2 = min_allocator<double>;
+ using M = std::flat_map<int, double, TransparentComparator, std::vector<int, A1>, std::vector<double, A2>>;
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ assert(m.size() == 7);
+ assert(m[one] == 1.5);
+ assert(m.size() == 7);
+ m[one] = -1.5;
+ assert(m[one] == -1.5);
+ assert(m.size() == 7);
+ assert(m[six] == 0);
+ assert(m.size() == 8);
+ m[six] = 6.5;
+ assert(m[six] == 6.5);
+ assert(m.size() == 8);
+ }
+ {
+ std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+
+ assert(m.size() == 7);
+ assert(m[one] == 1.5);
+ assert(m.size() == 7);
+ m[one] = -1.5;
+ assert(m[one] == -1.5);
+ assert(m.size() == 7);
+ assert(m[six] == 0);
+ assert(m.size() == 8);
+ m[six] = 6.5;
+ assert(m[six] == 6.5);
+ assert(m.size() == 8);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/empty.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.verify.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/empty.verify.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.verify.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/max_size.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
new file mode 100644
index 00000000000000..95c7dbd24f27c0
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// size_type size() const noexcept;
+
+#include <cassert>
+#include <flat_map>
+#include <vector>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, char>;
+ M m = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
+ ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+ ASSERT_NOEXCEPT(m.size());
+ assert(m.size() == 3);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
index 4aa55c1a0fbc43..803adf3a2a092e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -21,8 +21,40 @@
#include "test_macros.h"
#include "test_allocator.h"
+#include "../../../test_compare.h"
int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ using IL = std::initializer_list<std::pair<int, int>>;
+ static_assert(std::is_constructible_v<M1, const A1&>);
+ static_assert(!std::is_constructible_v<M1, const A2&>);
+ static_assert(!std::is_constructible_v<M2, const A2&>);
+ static_assert(!std::is_constructible_v<M3, const A2&>);
+ }
+ {
+ //explicit
+ using M =
+ std::flat_map<int,
+ long,
+ std::less<int>,
+ std::vector<int, test_allocator<int>>,
+ std::vector<long, test_allocator<long>>>;
+
+ static_assert(std::is_constructible_v<M, test_allocator<int>>);
+ static_assert(!std::is_convertible_v<test_allocator<int>, M>);
+ }
{
using A = test_allocator<short>;
using M =
@@ -38,6 +70,7 @@ int main(int, char**) {
assert(m.values().get_allocator().get_id() == 5);
}
{
+ // pmr
using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::polymorphic_allocator<int> pa = &mr;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
index df322a9c9d07cc..0e6d156ed9c405 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
@@ -27,7 +27,7 @@
int main(int, char**) {
{
- // The constructors in this subclause shall not participate in overload
+ // The constructors in this subclause shall not participate in overload
// resolution unless uses_allocator_v<key_container_type, Alloc> is true
// and uses_allocator_v<mapped_container_type, Alloc> is true.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
index 19b4b0faed354d..04180ff2b56ca2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
@@ -44,7 +44,7 @@ struct P {
int main(int, char**) {
{
- // The constructors in this subclause shall not participate in overload
+ // The constructors in this subclause shall not participate in overload
// resolution unless uses_allocator_v<key_container_type, Alloc> is true
// and uses_allocator_v<mapped_container_type, Alloc> is true.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
deleted file mode 100644
index a48b5d2d67ec5d..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers_compare.pass.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
-// const key_compare& comp = key_compare());
-// template<class Allocator>
-// flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-// const Allocator& a);
-
-#include <algorithm>
-#include <deque>
-#include <flat_map>
-#include <functional>
-#include <memory_resource>
-#include <vector>
-
-#include "min_allocator.h"
-#include "MoveOnly.h"
-#include "test_allocator.h"
-#include "test_iterators.h"
-#include "test_macros.h"
-#include "../../../test_compare.h"
-
-struct P {
- int first;
- int second;
- template <class T, class U>
- bool operator==(const std::pair<T, U>& rhs) const {
- return MoveOnly(first) == rhs.first && MoveOnly(second) == rhs.second;
- }
-};
-
-int main(int, char**) {
- using C = test_less<int>;
- {
- using M = std::flat_map<int, char, C>;
- std::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- std::vector<char> vs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
- auto m = M(ks, vs, C(2));
- assert((m.keys() == std::vector<int>{1, 2, 3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
- assert(m.key_comp() == C(2));
- m = M(std::move(ks), std::move(vs), C(3));
- assert(ks.empty()); // it was moved-from
- assert(vs.empty()); // it was moved-from
- assert((m.keys() == std::vector<int>{1, 2, 3}));
- LIBCPP_ASSERT((m.values() == std::vector<char>{1, 4, 6}));
- assert(m.key_comp() == C(3));
- }
- {
- P expected[] = {{1, 3}, {2, 1}, {3, 2}};
- using Ks = std::deque<int, min_allocator<int>>;
- using Vs = std::vector<MoveOnly, min_allocator<MoveOnly>>;
- using M = std::flat_map<int, MoveOnly, C, Ks, Vs>;
- Ks ks = {1, 3, 2};
- Vs vs;
- vs.push_back(3);
- vs.push_back(2);
- vs.push_back(1);
- auto m = M(std::move(ks), std::move(vs), C(2));
- assert(ks.empty()); // it was moved-from
- assert(vs.empty()); // it was moved-from
- assert(std::ranges::equal(m, expected, std::equal_to<>()));
- assert(m.key_comp() == C(2));
- }
- {
- using A = test_allocator<int>;
- using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
- auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
- auto m = M(std::move(ks), std::move(vs), C(2));
- assert(ks.empty()); // it was moved-from
- assert(vs.empty()); // it was moved-from
- assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(m.key_comp() == C(2));
- assert(m.keys().get_allocator() == A(5));
- assert(m.values().get_allocator() == A(6));
- }
- {
- using A = test_allocator<int>;
- using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
- auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
- auto m = M(ks, vs, C(2), A(4)); // replaces the allocators
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(m.key_comp() == C(2));
- assert(m.keys().get_allocator() == A(4));
- assert(m.values().get_allocator() == A(4));
- }
- {
- using A = test_allocator<int>;
- using M = std::flat_map<int, int, C, std::vector<int, A>, std::deque<int, A>>;
- auto ks = std::vector<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
- auto vs = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(6));
- M m = {ks, vs, C(2), A(4)}; // implicit ctor
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(m.key_comp() == C(2));
- assert(m.keys().get_allocator() == A(4));
- assert(m.values().get_allocator() == A(4));
- }
- {
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- assert(ks.get_allocator().resource() != &mr);
- assert(vs.get_allocator().resource() != &mr);
- vm.emplace_back(ks, vs, C(2));
- assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
- assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(vm[0].key_comp() == C(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- assert(ks.get_allocator().resource() != &mr);
- assert(vs.get_allocator().resource() != &mr);
- vm.emplace_back(std::move(ks), std::move(vs), C(2));
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(vm[0].key_comp() == C(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
-
-#if 0
- // Test all combinations of lvalue and rvalue containers (LWG 3802).
- {
- using C2 = test_less<MoveOnly>;
- int input[] = {1,1,1,2,2,3,2,3,3};
- const P expected[] = {{1,1}, {2,2}, {3,3}};
- {
- using M = std::flat_map<int, MoveOnly, C, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks(input, input + 9);
- std::pmr::vector<MoveOnly> vs(input, input + 9);
- vm.emplace_back(ks, std::move(vs), C(2)); // ill-formed before LWG 3802
- assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, int, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 9);
- std::pmr::vector<int> vs(input, input + 9);
- vm.emplace_back(std::move(ks), vs, C2(2)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C2(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, MoveOnly, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 9);
- std::pmr::vector<MoveOnly> vs(input, input + 9);
- vm.emplace_back(std::move(ks), std::move(vs), C2(2)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C2(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- }
- {
- using C2 = test_less<MoveOnly>;
- int input[] = {1,2,3};
- const P expected[] = {{1,1}, {2,2}, {3,3}};
- {
- using M = std::flat_map<int, MoveOnly, C, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks(input, input + 3);
- std::pmr::vector<MoveOnly> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, ks, std::move(vs), C(2)); // ill-formed before LWG 3802
- assert(ks.size() == 3); // ks' value is unchanged, since it was an lvalue above
- LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, int, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 3);
- std::pmr::vector<int> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, std::move(ks), vs, C2(2)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
- assert(vs.size() == 3); // vs' value is unchanged, since it was an lvalue above
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C2(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, MoveOnly, C2, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 3);
- std::pmr::vector<MoveOnly> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs), C2(2)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].key_comp() == C2(2));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- }
-#endif
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
index 91204f1688137c..99da4b33a45c98 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
@@ -24,6 +24,24 @@
#include "test_allocator.h"
int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ static_assert( std::is_constructible_v<M1, const M1&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, const M1&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, const M2&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, const M3&, const A2&>);
+ }
{
using C = test_less<int>;
std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
@@ -46,6 +64,7 @@ int main(int, char**) {
assert(mo.values().get_allocator() == test_allocator<char>(7));
}
{
+ // explicit(false)
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr1;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
index af15889a8cc678..e1f458e1e5977d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -213,6 +213,7 @@ void test_iter_iter() {
assert(std::ranges::equal(m, sorted_arr));
}
#if 0
+// spec has no CTAD for (Iter, Iter, Allocator) or (sorted_unique_t, Iter, Iter, Allocator)
{
std::flat_map m(std::begin(arr), std::end(arr), test_allocator<short>(0, 44));
@@ -289,6 +290,7 @@ void test_iter_iter_compare() {
assert(std::ranges::equal(m, sorted_arr));
}
#if 0
+// spec has no CTAD for (Iter, Iter, Compare, Allocator) or (sorted_unique_t, Iter, Iter, Compare, Allocator)
{
std::flat_map m(std::begin(arr), std::end(arr), C(), test_allocator<short>(0, 44));
@@ -349,6 +351,7 @@ void test_initializer_list() {
assert(std::ranges::equal(m, sorted_arr));
}
#if 0
+// spec has no CTAD for (initializer_list, Allocator) or (sorted_unique_t, initializer_list, Allocator)
{
std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, test_allocator<long>(0, 42));
@@ -384,6 +387,7 @@ void test_initializer_list_compare() {
assert(std::ranges::equal(m, sorted_arr));
}
#if 0
+// spec has no CTAD for (initializer_list, Compare, Allocator) or (sorted_unique_t, initializer_list, Compare, Allocator)
{
std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C(), test_allocator<long>(0, 42));
@@ -461,8 +465,8 @@ int main(int, char**) {
test_from_range();
test_from_range_compare();
- AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
+ AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
{
std::flat_map s = {std::make_pair(1, 'a')}; // flat_map(initializer_list<pair<int, char>>)
ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, char>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
index 4a5a16e3058b8f..379d1723705eb7 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
@@ -11,7 +11,10 @@
// <flat_map>
// flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare());
-// template<class Alloc> flat_map(initializer_list<value_type> il, const Alloc& a);
+// template<class Alloc>
+// flat_map(initializer_list<value_type> il, const Alloc& a);
+// template<class Alloc>
+// flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
#include <cassert>
#include <deque>
@@ -23,6 +26,9 @@
#include "test_macros.h"
#include "min_allocator.h"
+#include "test_allocator.h"
+
+#include "../../../test_compare.h"
struct DefaultCtableComp {
explicit DefaultCtableComp() { default_constructed_ = true; }
@@ -31,33 +37,78 @@ struct DefaultCtableComp {
};
int main(int, char**) {
- std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
- {
- using M = std::flat_map<int, short>;
- M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
- assert(std::equal(m.begin(), m.end(), expected, expected + 4));
- }
{
- using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
- M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
- assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ using IL = std::initializer_list<std::pair<int, int>>;
+ static_assert(std::is_constructible_v<M1, IL, const A1&>);
+ static_assert(!std::is_constructible_v<M1, IL, const A2&>);
+ static_assert(!std::is_constructible_v<M2, IL, const A2&>);
+ static_assert(!std::is_constructible_v<M3, IL, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, IL, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, IL, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, IL, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, IL, const C&, const A2&>);
}
+
{
- using M = std::flat_map<int, short>;
- std::initializer_list<M::value_type> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
- M m = il;
- assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+ // initializer_list<value_type> needs to match exactly
+ using M = std::flat_map<int, short>;
+ using C = typename M::key_compare;
static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>>);
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C>);
+ static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C, std::allocator<int>>);
static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C>);
+ static_assert(
+ !std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>>);
+ static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C>);
+ static_assert(
+ !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C, std::allocator<int>>);
static_assert(
!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
}
+
+ std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
+ {
+ // flat_map(initializer_list<value_type>);
+ using M = std::flat_map<int, short>;
+ std::initializer_list<std::pair<int, short>> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ M m(il);
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+ }
+ {
+ // flat_map(initializer_list<value_type>);
+ // explicit(false)
+ using M = std::flat_map<int, short>;
+ M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+ }
+ {
+ // flat_map(initializer_list<value_type>);
+ using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ M m = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+ }
{
using A = explicit_allocator<int>;
{
+ // flat_map(initializer_list<value_type>);
+ // different comparator
using M = std::flat_map<int, int, DefaultCtableComp, std::vector<int, A>, std::deque<int, A>>;
M m = {{1, 1}, {2, 2}, {3, 3}};
assert(m.size() == 1);
@@ -66,6 +117,7 @@ int main(int, char**) {
assert(m.key_comp().default_constructed_);
}
{
+ // flat_map(initializer_list<value_type>, const Allocator&);
using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
A a;
M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, a);
@@ -73,6 +125,36 @@ int main(int, char**) {
}
}
{
+ // flat_map(initializer_list<value_type>, const key_compare&);
+ using C = test_less<int>;
+ using M = std::flat_map<int, short, C>;
+ auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
+ assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+ assert(m.key_comp() == C(10));
+
+ // explicit(false)
+ M m2 = {{{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10)};
+ assert(m2 == m);
+ assert(m2.key_comp() == C(10));
+ }
+ {
+ // flat_map(initializer_list<value_type>, const key_compare&);
+ // Sorting uses the comparator that was passed in
+ using M = std::flat_map<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
+ auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+ assert(m.key_comp()(2, 1) == true);
+ }
+ {
+ // flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+ using A = explicit_allocator<int>;
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
+ A a;
+ M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, {}, a);
+ assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+ }
+ {
+ // pmr
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
@@ -82,5 +164,18 @@ int main(int, char**) {
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
+ {
+ // pmr compartor
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
+ vm.emplace_back(il, C(5));
+ assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ assert(vm[0].key_comp() == C(5));
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
deleted file mode 100644
index 6c61bfcc57ffa0..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list_compare.pass.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare());
-// template<class Alloc> flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
-
-#include <cassert>
-#include <deque>
-#include <flat_map>
-#include <functional>
-#include <memory_resource>
-#include <type_traits>
-#include <vector>
-
-#include "test_macros.h"
-#include "min_allocator.h"
-#include "../../../test_compare.h"
-
-int main(int, char**) {
- std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
- {
- using C = test_less<int>;
- using M = std::flat_map<int, short, C>;
- auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
- assert(std::equal(m.begin(), m.end(), expected, expected + 4));
- assert(m.key_comp() == C(10));
- }
- {
- // Sorting uses the comparator that was passed in
- using M = std::flat_map<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
- auto m = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
- assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
- assert(m.key_comp()(2, 1) == true);
- }
- {
- using C = test_less<int>;
- using M = std::flat_map<int, short, C>;
- std::initializer_list<M::value_type> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
- auto m = M(il, C(10));
- assert(std::equal(m.begin(), m.end(), expected, expected + 4));
- assert(m.key_comp() == C(10));
- static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C>);
- static_assert(std::is_constructible_v<M, std::initializer_list<std::pair<int, short>>, C, std::allocator<int>>);
- static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C>);
- static_assert(
- !std::is_constructible_v<M, std::initializer_list<std::pair<const int, short>>, C, std::allocator<int>>);
- static_assert(!std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C>);
- static_assert(
- !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, C, std::allocator<int>>);
- }
- {
- using A = explicit_allocator<int>;
- using M = std::flat_map<int, int, std::greater<int>, std::deque<int, A>, std::vector<int, A>>;
- A a;
- M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, {}, a);
- assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
- }
- {
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
- vm.emplace_back(il, C(5));
- assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- assert(vm[0].key_comp() == C(5));
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
index 4ea1541b8e2f89..dc5d8ee560a178 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -32,7 +32,7 @@
int main(int, char**) {
{
- // The constructors in this subclause shall not participate in overload
+ // The constructors in this subclause shall not participate in overload
// resolution unless uses_allocator_v<key_container_type, Alloc> is true
// and uses_allocator_v<mapped_container_type, Alloc> is true.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index e5e6597f2b3ca9..b998f7c876e107 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -26,6 +26,24 @@
#include "test_allocator.h"
int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ static_assert( std::is_constructible_v<M1, M1&&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, M1&&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, M2&&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, M3&&, const A2&>);
+ }
{
std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
using C = test_less<int>;
@@ -50,6 +68,7 @@ int main(int, char**) {
assert(mo.values().get_allocator() == A(7));
}
{
+ // explicit(false)
std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
index b597f15c8bda88..694a43fd9daa9a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
@@ -33,9 +33,43 @@
#include "test_macros.h"
#include "../../../test_compare.h"
+// test constraint container-compatible-range
+
+template <class V>
+using RangeOf = std::ranges::subrange<V*>;
+using Map = std::flat_map<int, double>;
+
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>>);
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>>);
+
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>, std::less<int>>);
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>, std::less<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::less<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::less<int>>);
+
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>, std::allocator<int>>);
+static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>, std::allocator<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::allocator<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::allocator<int>>);
+
+static_assert(std::is_constructible_v<Map,
+ std::from_range_t,
+ RangeOf<std::pair<int, double>>,
+ std::less<int>,
+ std::allocator<int>>);
+static_assert(std::is_constructible_v<Map,
+ std::from_range_t,
+ RangeOf<std::pair<short, double>>,
+ std::less<int>,
+ std::allocator<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::less<int>, std::allocator<int>>);
+static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::less<int>, std::allocator<int>>);
+
int main(int, char**) {
{
- // The constructors in this subclause shall not participate in overload
+ // The constructors in this subclause shall not participate in overload
// resolution unless uses_allocator_v<key_container_type, Alloc> is true
// and uses_allocator_v<mapped_container_type, Alloc> is true.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index 23bc612381d51e..cac6a348caeb55 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -36,7 +36,7 @@
int main(int, char**) {
{
- // The constructors in this subclause shall not participate in overload
+ // The constructors in this subclause shall not participate in overload
// resolution unless uses_allocator_v<key_container_type, Alloc> is true
// and uses_allocator_v<mapped_container_type, Alloc> is true.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
new file mode 100644
index 00000000000000..8f6a2e771f85b9
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
@@ -0,0 +1,207 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// flat_map(sorted_unique_t s, initializer_list<value_type> il,
+// const key_compare& comp = key_compare())
+// template<class Alloc>
+// flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+// template<class Alloc>
+// flat_map(sorted_unique_t, initializer_list<value_type> il,
+// const key_compare& comp, const Alloc& a);
+
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../../../test_compare.h"
+
+template <class T, class U>
+std::initializer_list<std::pair<T, U>> il = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+
+const auto il1 = il<int, int>;
+const auto il2 = il<int, short>;
+const auto il3 = il<short, int>;
+
+int main(int, char**) {
+ {
+ // The constructors in this subclause shall not participate in overload
+ // resolution unless uses_allocator_v<key_container_type, Alloc> is true
+ // and uses_allocator_v<mapped_container_type, Alloc> is true.
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = other_allocator<int>;
+ using V1 = std::vector<int, A1>;
+ using V2 = std::vector<int, A2>;
+ using M1 = std::flat_map<int, int, C, V1, V1>;
+ using M2 = std::flat_map<int, int, C, V1, V2>;
+ using M3 = std::flat_map<int, int, C, V2, V1>;
+ using IL = std::initializer_list<std::pair<int, int>>;
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, IL, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, IL, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, IL, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, IL, const A2&>);
+
+ static_assert(std::is_constructible_v<M1, std::sorted_unique_t, IL, const C&, const A1&>);
+ static_assert(!std::is_constructible_v<M1, std::sorted_unique_t, IL, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M2, std::sorted_unique_t, IL, const C&, const A2&>);
+ static_assert(!std::is_constructible_v<M3, std::sorted_unique_t, IL, const C&, const A2&>);
+ }
+ {
+ // initializer_list<value_type> needs to match exactly
+ using M = std::flat_map<int, short>;
+ using C = typename M::key_compare;
+ static_assert(std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<int, short>>>);
+ static_assert(std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<int, short>>, C>);
+ static_assert(std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<int, short>>,
+ C,
+ std::allocator<int>>);
+ static_assert(std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<int, short>>,
+ std::allocator<int>>);
+ static_assert(
+ !std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<const int, short>>>);
+ static_assert(
+ !std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<const int, short>>, C>);
+ static_assert(!std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<const int, short>>,
+ C,
+ std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<const int, short>>,
+ std::allocator<int>>);
+ static_assert(
+ !std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<const int, const short>>>);
+ static_assert(
+ !std::is_constructible_v<M, std::sorted_unique_t, std::initializer_list<std::pair<const int, const short>>, C>);
+ static_assert(!std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<const int, const short>>,
+ C,
+ std::allocator<int>>);
+ static_assert(!std::is_constructible_v<M,
+ std::sorted_unique_t,
+ std::initializer_list<std::pair<const int, const short>>,
+ std::allocator<int>>);
+ }
+
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>);
+ using M = std::flat_map<int, int>;
+ auto m = M(std::sorted_unique, il1);
+ auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ assert(m == expected);
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, il1};
+ assert(m2 == m);
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>, const key_compare&);
+ using M = std::flat_map<int, int, std::function<bool(int, int)>>;
+ auto m = M(std::sorted_unique, il1, std::less<int>());
+ assert(m == M({{1, 1}, {2, 2}, {4, 4}, {5, 5}}, std::less<>()));
+ assert(m.key_comp()(1, 2) == true);
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, il1, std::less<int>()};
+ assert(m2 == m);
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>, const key_compare&);
+ // greater
+ using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>, std::vector<int>>;
+ std::initializer_list<std::pair<int, int>> il4{{5, 5}, {4, 4}, {2, 2}, {1, 1}};
+ auto m = M(std::sorted_unique, il4, std::greater<int>());
+ assert((m == M{{5, 5}, {4, 4}, {2, 2}, {1, 1}}));
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>, const Allocator&)
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(std::sorted_unique, il2, A1(5));
+ auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ assert(m == expected);
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+
+ // explicit(false)
+ M m2 = {std::sorted_unique, il2, A1(5)};
+ assert(m2 == m);
+ assert(m2.keys().get_allocator() == A1(5));
+ assert(m2.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>, const key_compare&, const Allocator&);
+ using C = test_less<int>;
+ using A1 = test_allocator<int>;
+ using A2 = test_allocator<short>;
+ using M = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
+ auto m = M(std::sorted_unique, il2, C(3), A1(5));
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+ assert(m.key_comp() == C(3));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type>, const key_compare&, const Allocator&);
+ // explicit(false)
+ using A1 = test_allocator<short>;
+ using A2 = test_allocator<int>;
+ using M = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
+ M m = {std::sorted_unique, il3, {}, A1(5)}; // implicit ctor
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+ assert(m.keys().get_allocator() == A1(5));
+ assert(m.values().get_allocator() == A2(5));
+ }
+ {
+ // pmr cpp_17
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ vm.emplace_back(
+ std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+ assert(vm[0].key_comp() == C(3));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // pmr
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pair<int, int> ar[1] = {{42, 42}};
+ vm.emplace_back(std::sorted_unique, ar, ar, C(4));
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp() == C(4));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
index 0ad71ca8b8e992..2232e0b60455ae 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
@@ -70,7 +70,7 @@ int main(int, char**) {
assert(m2 == m);
}
{
- // flat_map(sorted_unique_t, InputIterator, InputIterator, const key_compare&);
+ // flat_map(sorted_unique_t, InputIterator, InputIterator);
// contiguous iterator
using C = test_less<int>;
using M = std::flat_map<int, int, C, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
similarity index 77%
rename from libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
index 2699a3a3c87e39..531e018c0cebba 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
@@ -10,13 +10,13 @@
// <flat_map>
-// iterator begin();
-// const_iterator begin() const;
-// iterator end();
-// const_iterator end() const;
+// iterator begin() noexcept;
+// const_iterator begin() const noexcept
+// iterator end() noexcept;
+// const_iterator end() const noexcept;
//
-// const_iterator cbegin() const;
-// const_iterator cend() const;
+// const_iterator cbegin() const noexcept;
+// const_iterator cend() const noexcept;
#include <cassert>
#include <cstddef>
@@ -29,14 +29,24 @@
int main(int, char**) {
{
- using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
- M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+ using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+ const M& cm = m;
ASSERT_SAME_TYPE(decltype(m.begin()), M::iterator);
ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.begin()), M::const_iterator);
ASSERT_SAME_TYPE(decltype(m.end()), M::iterator);
ASSERT_SAME_TYPE(decltype(m.cend()), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.end()), M::const_iterator);
+ static_assert(noexcept(m.begin()));
+ static_assert(noexcept(cm.begin()));
+ static_assert(noexcept(m.cbegin()));
+ static_assert(noexcept(m.end()));
+ static_assert(noexcept(cm.end()));
+ static_assert(noexcept(m.cend()));
assert(m.size() == 4);
assert(std::distance(m.begin(), m.end()) == 4);
+ assert(std::distance(cm.begin(), cm.end()) == 4);
assert(std::distance(m.cbegin(), m.cend()) == 4);
M::iterator i; // default-construct
i = m.begin(); // move-assignment
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/iterator_comparison.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/iterator_concept_conformance.compile.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/range_concept_conformance.compile.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
similarity index 79%
rename from libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
index 0bfff0c70b2739..e66cd81e2be928 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
@@ -10,13 +10,13 @@
// <flat_map>
-// reverse_iterator rbegin();
-// const_reverse_iterator rbegin() const;
-// reverse_iterator rend();
-// const_reverse_iterator rend() const;
+// reverse_iterator rbegin() noexcept;
+// const_reverse_iterator rbegin() const noexcept;
+// reverse_iterator rend() noexcept;
+// const_reverse_iterator rend() const noexcept;
//
-// const_reverse_iterator crbegin() const;
-// const_reverse_iterator crend() const;
+// const_reverse_iterator crbegin() const noexcept;
+// const_reverse_iterator crend() const noexcept;
#include <cassert>
#include <cstddef>
@@ -32,12 +32,21 @@
int main(int, char**) {
{
- using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
- M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+ using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+ const M& cm = m;
ASSERT_SAME_TYPE(decltype(m.rbegin()), M::reverse_iterator);
ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.rbegin()), M::const_reverse_iterator);
ASSERT_SAME_TYPE(decltype(m.rend()), M::reverse_iterator);
ASSERT_SAME_TYPE(decltype(m.crend()), M::const_reverse_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.rend()), M::const_reverse_iterator);
+ static_assert(noexcept(m.rbegin()));
+ static_assert(noexcept(cm.rbegin()));
+ static_assert(noexcept(m.crbegin()));
+ static_assert(noexcept(m.rend()));
+ static_assert(noexcept(cm.rend()));
+ static_assert(noexcept(m.crend()));
assert(m.size() == 4);
assert(std::distance(m.rbegin(), m.rend()) == 4);
assert(std::distance(m.crbegin(), m.crend()) == 4);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/clear.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
new file mode 100644
index 00000000000000..c4097781dbb226
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class... Args>
+// pair<iterator, bool> emplace(Args&&... args);
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+#include <tuple>
+
+#include "test_macros.h"
+#include "../../../Emplaceable.h"
+#include "DefaultOnly.h"
+#include "min_allocator.h"
+
+// Constraints: is_constructible_v<pair<key_type, mapped_type>, Args...> is true.
+template <class M, class... Args>
+concept CanEmplace = requires(M m, Args&&... args) { m.emplace(std::forward<Args>(args)...); };
+
+using Map = std::flat_map<Emplaceable, Emplaceable>;
+static_assert(CanEmplace<Map>);
+static_assert(CanEmplace<Map, Emplaceable, Emplaceable>);
+static_assert(CanEmplace<Map, std::piecewise_construct_t, std::tuple<int, double>, std::tuple<int, double>>);
+static_assert(!CanEmplace<Map, Emplaceable>);
+static_assert(!CanEmplace<Map, int, double>);
+
+int main(int, char**) {
+ {
+ // Emplaceable
+ using M = std::flat_map<int, Emplaceable>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(!r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ }
+ {
+ using M = std::flat_map<int, double>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ R r = m.emplace(M::value_type(2, 3.5));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+ }
+ {
+ using M =
+ std::flat_map<int,
+ Emplaceable,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<Emplaceable, min_allocator<Emplaceable>>>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(!r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ }
+ {
+ using M =
+ std::flat_map< int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ R r = m.emplace(M::value_type(2, 3.5));
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
new file mode 100644
index 00000000000000..315d3f4fc58061
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
@@ -0,0 +1,117 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class... Args>
+// iterator emplace_hint(const_iterator position, Args&&... args);
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "test_macros.h"
+#include "../../../Emplaceable.h"
+#include "DefaultOnly.h"
+#include "min_allocator.h"
+
+#if defined(_LIBCPP_VERSION)
+// spec only specifies `emplace(Args&&...)` is_constructible_v<pair<key_type, mapped_type>, Args...> is true.
+// nothing mentioned for emplace_hint
+template <class M, class... Args>
+concept CanEmplaceHint =
+ requires(M m, typename M::const_iterator i, Args&&... args) { m.emplace_hint(i, std::forward<Args>(args)...); };
+
+using Map = std::flat_map<Emplaceable, Emplaceable>;
+static_assert(CanEmplaceHint<Map>);
+static_assert(CanEmplaceHint<Map, Emplaceable, Emplaceable>);
+static_assert(CanEmplaceHint<Map, std::piecewise_construct_t, std::tuple<int, double>, std::tuple<int, double>>);
+static_assert(!CanEmplaceHint<Map, Emplaceable>);
+static_assert(!CanEmplaceHint<Map, int, double>);
+#endif
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, Emplaceable>;
+ using R = M::iterator;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ }
+ {
+ using M = std::flat_map<int, double>;
+ using R = M::iterator;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), M::value_type(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+ }
+ {
+ using M =
+ std::flat_map<int,
+ Emplaceable,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<Emplaceable, min_allocator<Emplaceable>>>;
+ using R = M::iterator;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ }
+ {
+ using M =
+ std::flat_map< int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ using R = M::iterator;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), M::value_type(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/erase_key.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
similarity index 89%
rename from libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
index 4cbac31c1857e1..5f3a92884cd15c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
@@ -20,10 +20,20 @@
#include <string>
#include <utility>
-#include "helpers.h"
+#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanErase = requires(M m, Transparent<int> k) { m.erase(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanErase<TransparentMap>);
+static_assert(!CanErase<const TransparentMap>);
+static_assert(!CanErase<NonTransparentMap>);
+static_assert(!CanErase<const NonTransparentMap>);
+
template <class Key, class It>
struct HeterogeneousKey {
explicit HeterogeneousKey(Key key, It it) : key_(key), it_(it) {}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
similarity index 98%
rename from libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
index 3c295a09f05c25..9996f2a74ae40d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/extract.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
@@ -17,7 +17,7 @@
#include <flat_map>
#include <functional>
-#include "helpers.h"
+#include "../helpers.h"
#include "test_macros.h"
template <class T>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
new file mode 100644
index 00000000000000..6016b86e3421f5
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// pair<iterator, bool> insert(const value_type& v);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class Container>
+void do_insert_cv_test() {
+ using M = Container;
+ using R = std::pair<typename M::iterator, bool>;
+ using VT = typename M::value_type;
+ M m;
+
+ const VT v1(2, 2.5);
+ std::same_as<R> decltype(auto) r = m.insert(v1);
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(r.first->first == 2);
+ assert(r.first->second == 2.5);
+
+ const VT v2(1, 1.5);
+ r = m.insert(v2);
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(r.first->first == 1);
+ assert(r.first->second == 1.5);
+
+ const VT v3(3, 3.5);
+ r = m.insert(v3);
+ assert(r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3.5);
+
+ const VT v4(3, 4.5);
+ r = m.insert(v4);
+ assert(!r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3.5);
+}
+
+int main(int, char**) {
+ do_insert_cv_test<std::flat_map<int, double> >();
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ do_insert_cv_test<M>();
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
new file mode 100644
index 00000000000000..e86a3a7e6f106a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// void insert(initializer_list<value_type> il);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+ {
+ using V = std::pair<const int, double>;
+ std::flat_map<int, double> m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert({
+ {4, 1},
+ {4, 1.5},
+ {4, 2},
+ {1, 1},
+ {1, 1.5},
+ {1, 2},
+ {2, 1},
+ {2, 1.5},
+ {2, 2},
+ });
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(*m.begin() == V(1, 1));
+ assert(*std::next(m.begin()) == V(2, 1));
+ assert(*std::next(m.begin(), 2) == V(3, 1));
+ assert(*std::next(m.begin(), 3) == V(4, 1));
+ }
+ {
+ using V = std::pair<const int, double>;
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert({
+ {4, 1},
+ {4, 1.5},
+ {4, 2},
+ {1, 1},
+ {1, 1.5},
+ {1, 2},
+ {2, 1},
+ {2, 1.5},
+ {2, 2},
+ {2, 1},
+ {2, 1.5},
+ {2, 2},
+ });
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(*m.begin() == V(1, 1));
+ assert(*std::next(m.begin()) == V(2, 1));
+ assert(*std::next(m.begin(), 2) == V(3, 1));
+ assert(*std::next(m.begin(), 3) == V(4, 1));
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
new file mode 100644
index 00000000000000..8bccec486e0cfe
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator insert(const_iterator position, const value_type& v);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class Container>
+void do_insert_iter_cv_test() {
+ using M = Container;
+ using R = typename M::iterator;
+ using VT = typename M::value_type;
+
+ M m;
+ const VT v1(2, 2.5);
+ std::same_as<R> decltype(auto) r = m.insert(m.end(), v1);
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(r->first == 2);
+ assert(r->second == 2.5);
+
+ const VT v2(1, 1.5);
+ r = m.insert(m.end(), v2);
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(r->first == 1);
+ assert(r->second == 1.5);
+
+ const VT v3(3, 3.5);
+ r = m.insert(m.end(), v3);
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3.5);
+
+ const VT v4(3, 4.5);
+ r = m.insert(m.end(), v4);
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3.5);
+}
+
+int main(int, char**) {
+ do_insert_iter_cv_test<std::flat_map<int, double> >();
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ do_insert_iter_cv_test<M>();
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
new file mode 100644
index 00000000000000..835cad4c4ad928
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// void insert(InputIterator first, InputIterator last);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+
+// test constraint InputIterator
+template <class M, class... Args>
+concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward<Args>(args)...); };
+
+using Map = std::flat_map<int, int>;
+using Pair = std::pair<int, int>;
+
+static_assert(CanInsert<Map, Pair*, Pair*>);
+static_assert(CanInsert<Map, cpp17_input_iterator<Pair*>, cpp17_input_iterator<Pair*>>);
+static_assert(!CanInsert<Map, int, int>);
+static_assert(!CanInsert<Map, cpp20_input_iterator<Pair*>, cpp20_input_iterator<Pair*>>);
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar1[] = {
+ P(2, 1),
+ P(2, 1.5),
+ P(2, 2),
+ P(1, 1),
+ P(1, 1.5),
+ P(1, 2),
+ P(3, 1),
+ P(3, 1.5),
+ P(3, 2),
+ };
+ P ar2[] = {
+ P(4, 1),
+ P(4, 1.5),
+ P(4, 2),
+ P(1, 1),
+ P(1, 1.5),
+ P(1, 2),
+ P(0, 1),
+ P(0, 1.5),
+ P(0, 2),
+ };
+ {
+ using M = std::flat_map<int, double>;
+ M m;
+ m.insert(cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+
+ m.insert(cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ M m;
+ m.insert(cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+ m.insert(cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
new file mode 100644
index 00000000000000..3eab817a2f24d2
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+// iterator insert(const_iterator position, value_type&&);
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+
+template <class Container, class Pair>
+void do_insert_iter_rv_test() {
+ using M = Container;
+ using P = Pair;
+ using R = typename M::iterator;
+ M m;
+ std::same_as<R> decltype(auto) r = m.insert(m.end(), P(2, 2));
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(r->first == 2);
+ assert(r->second == 2);
+
+ r = m.insert(m.end(), P(1, 1));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(r->first == 1);
+ assert(r->second == 1);
+
+ r = m.insert(m.end(), P(3, 3));
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3);
+
+ r = m.insert(m.end(), P(3, 4));
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3);
+}
+int main(int, char**) {
+ do_insert_iter_rv_test<std::flat_map<int, MoveOnly>, std::pair<int, MoveOnly>>();
+ do_insert_iter_rv_test<std::flat_map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
+
+ {
+ using M =
+ std::flat_map<int,
+ MoveOnly,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<MoveOnly, min_allocator<MoveOnly>>>;
+ using P = std::pair<int, MoveOnly>;
+ using CP = std::pair<const int, MoveOnly>;
+ do_insert_iter_rv_test<M, P>();
+ do_insert_iter_rv_test<M, CP>();
+ }
+ {
+ using M = std::flat_map<int, MoveOnly>;
+ using R = typename M::iterator;
+ M m;
+ R r = m.insert(m.end(), {2, MoveOnly(2)});
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(r->first == 2);
+ assert(r->second == 2);
+
+ r = m.insert(m.end(), {1, MoveOnly(1)});
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(r->first == 1);
+ assert(r->second == 1);
+
+ r = m.insert(m.end(), {3, MoveOnly(3)});
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3);
+
+ r = m.insert(m.end(), {3, MoveOnly(3)});
+ assert(r == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r->first == 3);
+ assert(r->second == 3);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
similarity index 87%
rename from libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
index 30843ee98297cd..f299edcc7d65bd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
@@ -25,6 +25,17 @@
#include "test_iterators.h"
#include "min_allocator.h"
+// test constraint container-compatible-range
+template <class M, class R>
+concept CanInsertRange = requires(M m, R&& r) { m.insert_range(std::forward<R>(r)); };
+
+using Map = std::flat_map<int, double>;
+
+static_assert(CanInsertRange<Map, std::ranges::subrange<std::pair<int, double>*>>);
+static_assert(CanInsertRange<Map, std::ranges::subrange<std::pair<short, double>*>>);
+static_assert(!CanInsertRange<Map, std::ranges::subrange<int*>>);
+static_assert(!CanInsertRange<Map, std::ranges::subrange<double*>>);
+
int main(int, char**) {
{
using P = std::pair<int, int>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range_stability.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/insert_range_stability.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range_stability.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
new file mode 100644
index 00000000000000..bff3c2ce4945b8
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// class flat_map
+
+// pair<iterator, bool> insert( value_type&& v);
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+
+template <class Container, class Pair>
+void do_insert_rv_test() {
+ using M = Container;
+ using P = Pair;
+ using R = std::pair<typename M::iterator, bool>;
+ M m;
+ std::same_as<R> decltype(auto) r = m.insert(P(2, 2));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(r.first->first == 2);
+ assert(r.first->second == 2);
+
+ r = m.insert(P(1, 1));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(r.first->first == 1);
+ assert(r.first->second == 1);
+
+ r = m.insert(P(3, 3));
+ assert(r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3);
+
+ r = m.insert(P(3, 3));
+ assert(!r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3);
+}
+
+int main(int, char**) {
+ do_insert_rv_test<std::flat_map<int, MoveOnly>, std::pair<int, MoveOnly>>();
+ do_insert_rv_test<std::flat_map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
+
+ {
+ using M =
+ std::flat_map<int,
+ MoveOnly,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<MoveOnly, min_allocator<MoveOnly>>>;
+ using P = std::pair<int, MoveOnly>;
+ using CP = std::pair<const int, MoveOnly>;
+ do_insert_rv_test<M, P>();
+ do_insert_rv_test<M, CP>();
+ }
+ {
+ using M = std::flat_map<int, MoveOnly>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ R r = m.insert({2, MoveOnly(2)});
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(r.first->first == 2);
+ assert(r.first->second == 2);
+
+ r = m.insert({1, MoveOnly(1)});
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(r.first->first == 1);
+ assert(r.first->second == 1);
+
+ r = m.insert({3, MoveOnly(3)});
+ assert(r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3);
+
+ r = m.insert({3, MoveOnly(3)});
+ assert(!r.second);
+ assert(r.first == std::ranges::prev(m.end()));
+ assert(m.size() == 3);
+ assert(r.first->first == 3);
+ assert(r.first->second == 3);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
new file mode 100644
index 00000000000000..155210c8906547
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// void insert(initializer_list<value_type> il);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+ {
+ using V = std::pair<const int, double>;
+ std::flat_map<int, double> m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert(std::sorted_unique,
+ {
+ {0, 1},
+ {1, 2},
+ {2, 1},
+ {4, 1},
+ });
+ assert(m.size() == 5);
+ assert(std::distance(m.begin(), m.end()) == 5);
+ assert(*m.begin() == V(0, 1));
+ assert(*std::next(m.begin()) == V(1, 1));
+ assert(*std::next(m.begin(), 2) == V(2, 1));
+ assert(*std::next(m.begin(), 3) == V(3, 1));
+ assert(*std::next(m.begin(), 4) == V(4, 1));
+ }
+ {
+ using V = std::pair<const int, double>;
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert(std::sorted_unique,
+ {
+ {0, 1},
+ {1, 2},
+ {2, 1},
+ {4, 1},
+ });
+ assert(m.size() == 5);
+ assert(std::distance(m.begin(), m.end()) == 5);
+ assert(*m.begin() == V(0, 1));
+ assert(*std::next(m.begin()) == V(1, 1));
+ assert(*std::next(m.begin(), 2) == V(2, 1));
+ assert(*std::next(m.begin(), 3) == V(3, 1));
+ assert(*std::next(m.begin(), 4) == V(4, 1));
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
new file mode 100644
index 00000000000000..f9dea06d45ad33
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template <class InputIterator>
+// void insert(sorted_unique_t, InputIterator first, InputIterator last);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "min_allocator.h"
+
+// test constraint InputIterator
+template <class M, class... Args>
+concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward<Args>(args)...); };
+
+using Map = std::flat_map<int, int>;
+using Pair = std::pair<int, int>;
+
+static_assert(CanInsert<Map, std::sorted_unique_t, Pair*, Pair*>);
+static_assert(CanInsert<Map, std::sorted_unique_t, cpp17_input_iterator<Pair*>, cpp17_input_iterator<Pair*>>);
+static_assert(!CanInsert<Map, std::sorted_unique_t, int, int>);
+static_assert(!CanInsert<Map, std::sorted_unique_t, cpp20_input_iterator<Pair*>, cpp20_input_iterator<Pair*>>);
+
+int main(int, char**) {
+ using P = std::pair<int, double>;
+ P ar1[] = {
+ P(1, 1),
+ P(2, 1),
+ P(3, 1),
+ };
+
+ P ar2[] = {
+ P(0, 1),
+ P(2, 2),
+ P(4, 1),
+ };
+ {
+ using M = std::flat_map<int, double>;
+ M m;
+ m.insert(std::sorted_unique,
+ cpp17_input_iterator<P*>(ar1),
+ cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+
+ m.insert(std::sorted_unique,
+ cpp17_input_iterator<P*>(ar2),
+ cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::deque<int, min_allocator<int>>,
+ std::deque<double, min_allocator<double>>>;
+ M m;
+ m.insert(std::sorted_unique,
+ cpp17_input_iterator<P*>(ar1),
+ cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+
+ m.insert(std::sorted_unique,
+ cpp17_input_iterator<P*>(ar2),
+ cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
similarity index 90%
rename from libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
index ebbb6dfd8b7fee..b822ebd3e8004a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/insert_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
@@ -23,6 +23,21 @@
#include "test_iterators.h"
#include "min_allocator.h"
+// Constraints: is_constructible_v<pair<key_type, mapped_type>, P> is true.
+template <class M, class...Args>
+concept CanInsert = requires (M m, Args&&... args) {
+ m.insert(std::forward<Args>(args)...);
+};
+
+using Map = std::flat_map<int, double>;
+using Iter = Map::const_iterator;
+
+static_assert(CanInsert<Map, std::pair<short, double>&&>);
+static_assert(CanInsert<Map, Iter, std::pair<short, double>&&>);
+static_assert(!CanInsert<Map, int>);
+static_assert(!CanInsert<Map, Iter, int>);
+
+
static int expensive_comparisons = 0;
static int cheap_comparisons = 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/comp.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/contains.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
new file mode 100644
index 00000000000000..f8ab721d23440d
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> bool contains(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanContains = requires(M m, Transparent<int> k) { m.contains(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanContains<TransparentMap>);
+static_assert(CanContains<const TransparentMap>);
+static_assert(!CanContains<NonTransparentMap>);
+static_assert(!CanContains<const NonTransparentMap>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.contains(Transparent<std::string>{"abc"})), bool);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(Transparent<std::string>{"b"})), bool);
+ assert(m.contains(Transparent<std::string>{"alpha"}) == true);
+ assert(m.contains(Transparent<std::string>{"beta"}) == true);
+ assert(m.contains(Transparent<std::string>{"epsilon"}) == true);
+ assert(m.contains(Transparent<std::string>{"eta"}) == true);
+ assert(m.contains(Transparent<std::string>{"gamma"}) == true);
+ assert(m.contains(Transparent<std::string>{"al"}) == false);
+ assert(m.contains(Transparent<std::string>{""}) == false);
+ assert(m.contains(Transparent<std::string>{"g"}) == false);
+ }
+#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.contains(StartsWith('b'))), bool);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(StartsWith('b'))), bool);
+ assert(m.contains("beta") == true);
+ assert(m.contains("delta") == false);
+ assert(m.contains("zeta") == false);
+ assert(m.contains(StartsWith('b')) == true);
+ assert(m.contains(StartsWith('d')) == false);
+ assert(m.contains(StartsWith('e')) == true);
+ assert(m.contains(StartsWith('z')) == false);
+ }
+#endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/count.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
similarity index 79%
rename from libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
index 80c4dbb7bef19e..47d8b90d3dd6a1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
@@ -17,9 +17,19 @@
#include <string>
#include <utility>
-#include "helpers.h"
+#include "../helpers.h"
#include "test_macros.h"
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanCount = requires(M m, Transparent<int> k) { m.count(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanCount<TransparentMap>);
+static_assert(CanCount<const TransparentMap>);
+static_assert(!CanCount<NonTransparentMap>);
+static_assert(!CanCount<const NonTransparentMap>);
+
int main(int, char**) {
{
using M = std::flat_map<std::string, int, TransparentComparator>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/equal_range.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
similarity index 85%
rename from libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
index 3433094f1c0d76..13de8d34545852 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
@@ -18,9 +18,19 @@
#include <string>
#include <utility>
-#include "helpers.h"
+#include "../helpers.h"
#include "test_macros.h"
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanEqualRange = requires(M m, Transparent<int> k) { m.equal_range(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanEqualRange<TransparentMap>);
+static_assert(CanEqualRange<const TransparentMap>);
+static_assert(!CanEqualRange<NonTransparentMap>);
+static_assert(!CanEqualRange<const NonTransparentMap>);
+
int main(int, char**) {
{
using M = std::flat_map<std::string, int, TransparentComparator>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/find.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
new file mode 100644
index 00000000000000..064b5013b51497
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator find(const K& x);
+// template<class K> const_iterator find(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanFind = requires(M m, Transparent<int> k) { m.find(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanFind<TransparentMap>);
+static_assert(CanFind<const TransparentMap>);
+static_assert(!CanFind<NonTransparentMap>);
+static_assert(!CanFind<const NonTransparentMap>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.find(Transparent<std::string>{"abc"})), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(Transparent<std::string>{"b"})), M::const_iterator);
+
+ auto test_find = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.find(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
+
+ test_find(m, "alpha", 0);
+ test_find(m, "beta", 1);
+ test_find(m, "epsilon", 2);
+ test_find(m, "eta", 3);
+ test_find(m, "gamma", 4);
+ test_find(m, "charlie", 5);
+ test_find(m, "aaa", 5);
+ test_find(m, "zzz", 5);
+ test_find(cm, "alpha", 0);
+ test_find(cm, "beta", 1);
+ test_find(cm, "epsilon", 2);
+ test_find(cm, "eta", 3);
+ test_find(cm, "gamma", 4);
+ test_find(cm, "charlie", 5);
+ test_find(cm, "aaa", 5);
+ test_find(cm, "zzz", 5);
+ }
+#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.find(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(StartsWith('b'))), M::const_iterator);
+ assert(m.find("beta") == m.begin() + 1);
+ assert(m.find("delta") == m.end());
+ assert(m.find("zeta") == m.end());
+ assert(m.find(StartsWith('b')) == m.begin() + 1);
+ assert(m.find(StartsWith('d')) == m.end());
+ auto it = m.find(StartsWith('e'));
+ assert(m.begin() + 2 <= it && it <= m.begin() + 3); // either is acceptable
+ LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
+ assert(m.find(StartsWith('z')) == m.end());
+ }
+#endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/lower_bound.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
new file mode 100644
index 00000000000000..90befb129b3a84
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator lower_bound(const K& x);
+// template<class K> const_iterator lower_bound(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanLowerBound = requires(M m, Transparent<int> k) { m.lower_bound(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanLowerBound<TransparentMap>);
+static_assert(CanLowerBound<const TransparentMap>);
+static_assert(!CanLowerBound<NonTransparentMap>);
+static_assert(!CanLowerBound<const NonTransparentMap>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), M::const_iterator);
+
+ auto test_lower_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.lower_bound(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
+
+ test_lower_bound(m, "abc", 0);
+ test_lower_bound(m, "alpha", 0);
+ test_lower_bound(m, "beta", 1);
+ test_lower_bound(m, "bets", 2);
+ test_lower_bound(m, "charlie", 2);
+ test_lower_bound(m, "echo", 2);
+ test_lower_bound(m, "epsilon", 2);
+ test_lower_bound(m, "eta", 3);
+ test_lower_bound(m, "gamma", 4);
+ test_lower_bound(m, "golf", 5);
+ test_lower_bound(m, "zzz", 5);
+
+ test_lower_bound(cm, "abc", 0);
+ test_lower_bound(cm, "alpha", 0);
+ test_lower_bound(cm, "beta", 1);
+ test_lower_bound(cm, "bets", 2);
+ test_lower_bound(cm, "charlie", 2);
+ test_lower_bound(cm, "echo", 2);
+ test_lower_bound(cm, "epsilon", 2);
+ test_lower_bound(cm, "eta", 3);
+ test_lower_bound(cm, "gamma", 4);
+ test_lower_bound(cm, "golf", 5);
+ test_lower_bound(cm, "zzz", 5);
+ }
+#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(StartsWith('b'))), M::const_iterator);
+ assert(m.lower_bound("beta") == m.begin() + 1);
+ assert(m.lower_bound("delta") == m.begin() + 2);
+ assert(m.lower_bound("zeta") == m.begin() + 5);
+ assert(m.lower_bound(StartsWith('b')) == m.begin() + 1);
+ assert(m.lower_bound(StartsWith('d')) == m.begin() + 2);
+ assert(m.lower_bound(StartsWith('e')) == m.begin() + 2);
+ assert(m.lower_bound(StartsWith('z')) == m.begin() + 5);
+ }
+#endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
similarity index 100%
rename from libcxx/test/std/containers/container.adaptors/flat.map/upper_bound.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
new file mode 100644
index 00000000000000..b57e101e35eb3c
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K> iterator upper_bound(const K& x);
+// template<class K> const_iterator upper_bound(const K& x) const;
+
+#include <cassert>
+#include <flat_map>
+#include <string>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+
+// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
+template <class M>
+concept CanUpperBound = requires(M m, Transparent<int> k) { m.upper_bound(k); };
+using TransparentMap = std::flat_map<int, double, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, double, NonTransparentComparator>;
+static_assert(CanUpperBound<TransparentMap>);
+static_assert(CanUpperBound<const TransparentMap>);
+static_assert(!CanUpperBound<NonTransparentMap>);
+static_assert(!CanUpperBound<const NonTransparentMap>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<std::string, int, TransparentComparator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), M::const_iterator);
+
+ auto test_upper_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.upper_bound(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
+
+ test_upper_bound(m, "abc", 0);
+ test_upper_bound(m, "alpha", 1);
+ test_upper_bound(m, "beta", 2);
+ test_upper_bound(m, "bets", 2);
+ test_upper_bound(m, "charlie", 2);
+ test_upper_bound(m, "echo", 2);
+ test_upper_bound(m, "epsilon", 3);
+ test_upper_bound(m, "eta", 4);
+ test_upper_bound(m, "gamma", 5);
+ test_upper_bound(m, "golf", 5);
+ test_upper_bound(m, "zzz", 5);
+
+ test_upper_bound(cm, "abc", 0);
+ test_upper_bound(cm, "alpha", 1);
+ test_upper_bound(cm, "beta", 2);
+ test_upper_bound(cm, "bets", 2);
+ test_upper_bound(cm, "charlie", 2);
+ test_upper_bound(cm, "echo", 2);
+ test_upper_bound(cm, "epsilon", 3);
+ test_upper_bound(cm, "eta", 4);
+ test_upper_bound(cm, "gamma", 5);
+ test_upper_bound(cm, "golf", 5);
+ test_upper_bound(cm, "zzz", 5);
+ }
+#if 0
+// do we really want to support this weird comparator that gives different answer for Key and Kp?
+ {
+ using M = std::flat_map<std::string, int, StartsWith::Less>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(StartsWith('b'))), M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(StartsWith('b'))), M::const_iterator);
+ assert(m.upper_bound("beta") == m.begin() + 2);
+ assert(m.upper_bound("delta") == m.begin() + 2);
+ assert(m.upper_bound("zeta") == m.begin() + 5);
+ assert(m.upper_bound(StartsWith('b')) == m.begin() + 2);
+ assert(m.upper_bound(StartsWith('d')) == m.begin() + 2);
+ assert(m.upper_bound(StartsWith('e')) == m.begin() + 4);
+ assert(m.upper_bound(StartsWith('z')) == m.begin() + 5);
+ }
+#endif
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 1e9663afdf40ca..0a3044cade7c4c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -45,20 +45,32 @@ struct CopyOnlyVector : std::vector<T> {
CopyOnlyVector& operator=(CopyOnlyVector& other) { return this->operator=(other); }
};
-template <class T>
+template <class T, bool ConvertibleToT = false>
struct Transparent {
T t;
+
+ operator T() const
+ requires ConvertibleToT
+ {
+ return t;
+ }
};
+template <class T>
+using ConvertibleTransparent = Transparent<T, true>;
+
+template <class T>
+using NonConvertibleTransparent = Transparent<T, false>;
+
struct TransparentComparator {
- using is_transparent = void;
- template <class T>
- bool operator()(const T& t, const Transparent<T>& transparent) const {
+ using is_transparent = void;
+ template <class T, bool Convertible>
+ bool operator()(const T& t, const Transparent<T, Convertible>& transparent) const {
return t < transparent.t;
}
- template <class T>
- bool operator()(const Transparent<T>& transparent, const T& t) const {
+ template <class T, bool Convertible>
+ bool operator()(const Transparent<T, Convertible>& transparent, const T& t) const {
return transparent.t < t;
}
@@ -68,4 +80,20 @@ struct TransparentComparator {
}
};
+struct NonTransparentComparator {
+ template <class T, bool Convertible>
+ bool operator()(const T&, const Transparent<T, Convertible>&) const;
+
+ template <class T, bool Convertible>
+ bool operator()(const Transparent<T, Convertible>&, const T&) const;
+
+ template <class T>
+ bool operator()(const T&, const T&) const;
+};
+
+struct NoDefaultCtr {
+ NoDefaultCtr() = delete;
+};
+
+
#endif // SUPPORT_FLAT_MAP_HELPERS_H
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
deleted file mode 100644
index a5dca0e9f80423..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/lower_bound_transparent.pass.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template<class K> iterator lower_bound(const K& x);
-// template<class K> const_iterator lower_bound(const K& x) const;
-
-#include <cassert>
-#include <flat_map>
-#include <string>
-#include <utility>
-
-#include "helpers.h"
-#include "test_macros.h"
-
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.lower_bound(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(StartsWith('b'))), M::const_iterator);
- assert(m.lower_bound("beta") == m.begin() + 1);
- assert(m.lower_bound("delta") == m.begin() + 2);
- assert(m.lower_bound("zeta") == m.begin() + 5);
- assert(m.lower_bound(StartsWith('b')) == m.begin() + 1);
- assert(m.lower_bound(StartsWith('d')) == m.begin() + 2);
- assert(m.lower_bound(StartsWith('e')) == m.begin() + 2);
- assert(m.lower_bound(StartsWith('z')) == m.begin() + 5);
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/types.compile.pass.cpp
similarity index 63%
rename from libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp
rename to libcxx/test/std/containers/container.adaptors/flat.map/types.compile.pass.cpp
index ecce6534fd57b3..ea9d4d7fca67f0 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/typedef.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/types.compile.pass.cpp
@@ -37,6 +37,7 @@
#include <ranges>
#include <string>
#include <vector>
+#include "min_allocator.h"
void test() {
{
@@ -88,4 +89,45 @@ void test() {
static_assert(std::is_same_v<decltype(M::containers::keys), std::deque<std::string>>);
static_assert(std::is_same_v<decltype(M::containers::values), std::deque<A>>);
}
+ {
+ using C = std::flat_map<int, short>;
+ static_assert(std::is_same_v<C::key_type, int>);
+ static_assert(std::is_same_v<C::mapped_type, short>);
+ static_assert(std::is_same_v<C::value_type, std::pair<int, short>>);
+ static_assert(std::is_same_v<C::key_compare, std::less<int>>);
+ static_assert(!std::is_same_v<C::value_compare, std::less<int>>);
+ static_assert(std::is_same_v<C::reference, std::pair<const int&, short&>>);
+ static_assert(std::is_same_v<C::const_reference, std::pair<const int&, const short&>>);
+ static_assert(std::random_access_iterator<C::iterator>);
+ static_assert(std::random_access_iterator<C::const_iterator>);
+ static_assert(std::random_access_iterator<C::reverse_iterator>);
+ static_assert(std::random_access_iterator<C::const_reverse_iterator>);
+ static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
+ static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
+ static_assert(std::is_same_v<C::size_type, std::size_t>);
+ static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
+ static_assert(std::is_same_v<C::key_container_type, std::vector<int>>);
+ static_assert(std::is_same_v<C::mapped_container_type, std::vector<short>>);
+ }
+ {
+ using C = std::flat_map<short, int, std::greater<long>, std::deque<short, min_allocator<short>>>;
+ static_assert(std::is_same_v<C::key_type, short>);
+ static_assert(std::is_same_v<C::mapped_type, int>);
+ static_assert(std::is_same_v<C::value_type, std::pair<short, int>>);
+ static_assert(std::is_same_v<C::key_compare, std::greater<long>>);
+ static_assert(!std::is_same_v<C::value_compare, std::greater<long>>);
+ static_assert(std::is_same_v<C::reference, std::pair<const short&, int&>>);
+ static_assert(std::is_same_v<C::const_reference, std::pair<const short&, const int&>>);
+ static_assert(std::random_access_iterator<C::iterator>);
+ static_assert(std::random_access_iterator<C::const_iterator>);
+ static_assert(std::random_access_iterator<C::reverse_iterator>);
+ static_assert(std::random_access_iterator<C::const_reverse_iterator>);
+ static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
+ static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
+ // size_type is invariably size_t
+ static_assert(std::is_same_v<C::size_type, std::size_t>);
+ static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
+ static_assert(std::is_same_v<C::key_container_type, std::deque<short, min_allocator<short>>>);
+ static_assert(std::is_same_v<C::mapped_container_type, std::vector<int>>);
+ }
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
deleted file mode 100644
index 02d2d799db713a..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/types.pass.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template<class Key, class T, class Compare = less<Key>,
-// class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
-// class flat_map {
-// public:
-// // types
-// using key_type = Key;
-// using mapped_type = T;
-// using value_type = pair<key_type, mapped_type>;
-// using key_compare = Compare;
-// using reference = pair<const key_type&, mapped_type&>;
-// using const_reference = pair<const key_type&, const mapped_type&>;
-// using size_type = size_t;
-// using difference_type = ptrdiff_t;
-// using iterator = implementation-defined; // see [container.requirements]
-// using const_iterator = implementation-defined; // see [container.requirements]
-// using reverse_iterator = std::reverse_iterator<iterator>;
-// using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-// using key_container_type = KeyContainer;
-// using mapped_container_type = MappedContainer;
-
-#include <deque>
-#include <flat_map>
-#include <functional>
-#include <type_traits>
-#include <vector>
-
-#include "test_macros.h"
-#include "min_allocator.h"
-
-int main(int, char**) {
- {
- using C = std::flat_map<int, short>;
- static_assert(std::is_same_v<C::key_type, int>);
- static_assert(std::is_same_v<C::mapped_type, short>);
- static_assert(std::is_same_v<C::value_type, std::pair<int, short>>);
- static_assert(std::is_same_v<C::key_compare, std::less<int>>);
- static_assert(!std::is_same_v<C::value_compare, std::less<int>>);
- static_assert(std::is_same_v<C::reference, std::pair<const int&, short&>>);
- static_assert(std::is_same_v<C::const_reference, std::pair<const int&, const short&>>);
- static_assert(std::random_access_iterator<C::iterator>);
- static_assert(std::random_access_iterator<C::const_iterator>);
- static_assert(std::random_access_iterator<C::reverse_iterator>);
- static_assert(std::random_access_iterator<C::const_reverse_iterator>);
- static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
- static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
- static_assert(std::is_same_v<C::size_type, std::size_t>);
- static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
- static_assert(std::is_same_v<C::key_container_type, std::vector<int>>);
- static_assert(std::is_same_v<C::mapped_container_type, std::vector<short>>);
- }
- {
- using C = std::flat_map<short, int, std::greater<long>, std::deque<short, min_allocator<short>>>;
- static_assert(std::is_same_v<C::key_type, short>);
- static_assert(std::is_same_v<C::mapped_type, int>);
- static_assert(std::is_same_v<C::value_type, std::pair<short, int>>);
- static_assert(std::is_same_v<C::key_compare, std::greater<long>>);
- static_assert(!std::is_same_v<C::value_compare, std::greater<long>>);
- static_assert(std::is_same_v<C::reference, std::pair<const short&, int&>>);
- static_assert(std::is_same_v<C::const_reference, std::pair<const short&, const int&>>);
- static_assert(std::random_access_iterator<C::iterator>);
- static_assert(std::random_access_iterator<C::const_iterator>);
- static_assert(std::random_access_iterator<C::reverse_iterator>);
- static_assert(std::random_access_iterator<C::const_reverse_iterator>);
- static_assert(std::is_same_v<C::reverse_iterator, std::reverse_iterator<C::iterator>>);
- static_assert(std::is_same_v<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator>>);
- // size_type is invariably size_t
- static_assert(std::is_same_v<C::size_type, std::size_t>);
- static_assert(std::is_same_v<C::difference_type, std::ptrdiff_t>);
- static_assert(std::is_same_v<C::key_container_type, std::deque<short, min_allocator<short>>>);
- static_assert(std::is_same_v<C::mapped_container_type, std::vector<int>>);
- }
- return 0;
-}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
deleted file mode 100644
index 6c06eea59c9658..00000000000000
--- a/libcxx/test/std/containers/container.adaptors/flat.map/upper_bound_transparent.pass.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// <flat_map>
-
-// template<class K> iterator upper_bound(const K& x);
-// template<class K> const_iterator upper_bound(const K& x) const;
-
-#include <cassert>
-#include <flat_map>
-#include <string>
-#include <utility>
-
-#include "helpers.h"
-#include "test_macros.h"
-
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.upper_bound(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(StartsWith('b'))), M::const_iterator);
- assert(m.upper_bound("beta") == m.begin() + 2);
- assert(m.upper_bound("delta") == m.begin() + 2);
- assert(m.upper_bound("zeta") == m.begin() + 5);
- assert(m.upper_bound(StartsWith('b')) == m.begin() + 2);
- assert(m.upper_bound(StartsWith('d')) == m.begin() + 2);
- assert(m.upper_bound(StartsWith('e')) == m.begin() + 4);
- assert(m.upper_bound(StartsWith('z')) == m.begin() + 5);
- }
- return 0;
-}
>From 5e7ed196027b689f6d3361d4251f0b94e350b46b Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 21 Sep 2024 21:27:29 +0100
Subject: [PATCH 17/40] input iterator & vector<bool> ban
---
libcxx/include/__flat_map/flat_map.h | 65 ++++++++++---------
.../flat.map/flat.map.access/at.pass.cpp | 1 +
.../flat.map/flat.map.capacity/empty.pass.cpp | 3 +
.../flat.map.erasure/erase_if.pass.cpp | 4 ++
...rator_concept_conformance.compile.pass.cpp | 3 +
...range_concept_conformance.compile.pass.cpp | 5 +-
.../flat.map.modifiers/clear.pass.cpp | 3 +
.../flat.map.operations/contains.pass.cpp | 3 +
.../flat.map.operations/count.pass.cpp | 3 +
.../flat.map.operations/equal_range.pass.cpp | 3 +
.../flat.map.operations/find.pass.cpp | 3 +
.../flat.map.operations/lower_bound.pass.cpp | 3 +
.../flat.map.operations/upper_bound.pass.cpp | 3 +
13 files changed, 71 insertions(+), 31 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index e0451e4a9a8223..d6203bd6ac3184 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -28,7 +28,6 @@
#include <__functional/is_transparent.h>
#include <__functional/operations.h>
#include <__iterator/concepts.h>
-#include <__iterator/cpp17_iterator_concepts.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/ranges_iterator_traits.h>
@@ -74,18 +73,23 @@ class flat_map {
template <class, class, class, class, class>
friend class flat_map;
+ static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
+ static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
+ static_assert(!is_same_v<_KeyContainer, std::vector<bool>>, "vector<bool> is not a sequence container");
+ static_assert(!is_same_v<_MappedContainer, std::vector<bool>>, "vector<bool> is not a sequence container");
+
public:
// types
- using key_type = _Key;
- using mapped_type = _Tp;
- using value_type = pair<key_type, mapped_type>;
- using key_compare = __type_identity_t<_Compare>;
- // TODO : the following is the spec, but not implementable for vector<bool>
- // using reference = pair<const key_type&, mapped_type&>;
- // using const_reference = pair<const key_type&, const mapped_type&>;
- using reference = pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<_MappedContainer>>;
- using const_reference =
- pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<const _MappedContainer>>;
+ using key_type = _Key;
+ using mapped_type = _Tp;
+ using value_type = pair<key_type, mapped_type>;
+ using key_compare = __type_identity_t<_Compare>;
+ using reference = pair<const key_type&, mapped_type&>;
+ using const_reference = pair<const key_type&, const mapped_type&>;
+ // TODO : to support vector<bool> in the future, the following typedefs need to replace the above
+ // using reference = pair<ranges::range_reference_t<const _KeyContainer>,
+ // ranges::range_reference_t<_MappedContainer>>; using const_reference =
+ // pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<const _MappedContainer>>;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator = __iterator<false>; // see [container.requirements]
@@ -95,9 +99,6 @@ class flat_map {
using key_container_type = _KeyContainer;
using mapped_container_type = _MappedContainer;
- static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
- static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
-
class value_compare {
private:
key_compare __comp_;
@@ -364,23 +365,24 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI explicit flat_map(const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {}
- template <__cpp17_input_iterator _InputIterator>
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(__first, __last);
}
- template <__cpp17_input_iterator _InputIterator, class _Allocator>
- requires __allocator_ctor_constraint<_Allocator>
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
_LIBCPP_HIDE_FROM_ABI
flat_map(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
insert(__first, __last);
}
- template <__cpp17_input_iterator _InputIterator, class _Allocator>
- requires __allocator_ctor_constraint<_Allocator>
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
_LIBCPP_HIDE_FROM_ABI flat_map(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
insert(__first, __last);
@@ -409,14 +411,15 @@ class flat_map {
insert_range(std::forward<_Range>(__rg));
}
- template <__cpp17_input_iterator _InputIterator>
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
: __containers_(), __compare_(__comp) {
insert(sorted_unique, __first, __last);
}
- template <__cpp17_input_iterator _InputIterator, class _Allocator>
- requires __allocator_ctor_constraint<_Allocator>
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t,
_InputIterator __first,
@@ -427,8 +430,8 @@ class flat_map {
insert(sorted_unique, __first, __last);
}
- template <__cpp17_input_iterator _InputIterator, class _Allocator>
- requires __allocator_ctor_constraint<_Allocator>
+ template <class _InputIterator, class _Allocator>
+ requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
_LIBCPP_HIDE_FROM_ABI
flat_map(sorted_unique_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_empty_tag{}, __alloc) {
@@ -621,7 +624,8 @@ class flat_map {
return emplace_hint(__hint, std::forward<_Pp>(__x));
}
- template <__cpp17_input_iterator _InputIterator>
+ 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);
@@ -629,7 +633,8 @@ class flat_map {
__append_sort_merge_unique</*WasSorted = */ false>(std::move(__first), std::move(__last));
}
- template <__cpp17_input_iterator _InputIterator>
+ template <class _InputIterator>
+ requires __has_input_iterator_category<_InputIterator>::value
void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) {
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
__reserve(__last - __first);
@@ -1253,13 +1258,13 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
_KeyContainer,
_MappedContainer>;
-template <__cpp17_input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
- requires(!__is_allocator<_Compare>::value)
+template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+ requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
-template <__cpp17_input_iterator _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
- requires(!__is_allocator<_Compare>::value)
+template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
+ requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
index 97cb64de8e4d7a..57d5a486548625 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
@@ -17,6 +17,7 @@
#include <flat_map>
#include <functional>
#include <stdexcept>
+#include <vector>
#include "min_allocator.h"
#include "test_macros.h"
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
index 72ac225e25a062..762b5596b75741 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
@@ -46,6 +46,8 @@ int main(int, char**) {
m.clear();
assert(m.empty());
}
+#if 0
+ // vector<bool> is not supported
{
typedef std::flat_map<bool, bool> M;
M m;
@@ -58,5 +60,6 @@ int main(int, char**) {
m.clear();
assert(m.empty());
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
index e225285e8d8259..c6eda7f042639b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
@@ -88,6 +88,9 @@ int main(int, char**) {
test<std::flat_map<int, char, std::greater<int>, std::deque<int, test_allocator<int>>>>();
test<std::flat_map<long, int>>();
test<std::flat_map<double, int>>();
+
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
std::flat_map<bool, bool> fs = {{true, false}, {false, true}};
@@ -98,5 +101,6 @@ int main(int, char**) {
assert(fs.empty());
assert(n == 1);
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
index 04117a690f46ae..6edccf3370fcd5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -100,6 +100,8 @@ void test() {
static_assert(std::indirectly_movable_storable<RI, std::pair<char*, int>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<char*, int>*>);
}
+#if 0
+ // vector<bool> is not supported
{
using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
using I = C::iterator;
@@ -139,4 +141,5 @@ void test() {
static_assert(std::indirectly_movable_storable<RI, std::pair<char, bool>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<char, bool>*>);
}
+#endif
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
index 981267f6604a02..8a0beaa5ad9db2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
@@ -40,6 +40,8 @@ void test() {
static_assert(!std::ranges::borrowed_range<const C>);
static_assert(!std::ranges::viewable_range<const C>);
}
+#if 0
+ // vector<bool> is not supported
{
using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
@@ -62,5 +64,6 @@ void test() {
static_assert(std::ranges::sized_range<const C>);
static_assert(!std::ranges::borrowed_range<const C>);
static_assert(!std::ranges::viewable_range<const C>);
- }
+
+#endif
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
index 0ad01d93c94386..9595ac202a0e2e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
@@ -47,6 +47,8 @@ int main(int, char**) {
m.clear();
assert(m.size() == 0);
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
M m = {{true, false}, {false, true}};
@@ -56,5 +58,6 @@ int main(int, char**) {
m.clear();
assert(m.size() == 0);
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
index 930ee4329d1d9c..6569625bf8b7fb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
@@ -54,6 +54,8 @@ int main(int, char**) {
m.clear();
assert(!m.contains(1));
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, int>;
M m = {{true, 1}, {false, 2}};
@@ -69,5 +71,6 @@ int main(int, char**) {
assert(!m.contains(true));
assert(!m.contains(false));
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
index a0858c6adc6803..e5a143046f5f58 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
@@ -52,6 +52,8 @@ int main(int, char**) {
assert(std::as_const(m).count(8) == 1);
assert(std::as_const(m).count(9) == 0);
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, int>;
M m = {{true, 1}, {false, 2}};
@@ -68,5 +70,6 @@ int main(int, char**) {
assert(m.count(true) == 0);
assert(m.count(false) == 0);
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
index 1c95006bddeec6..e72f50c7302a45 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
@@ -66,6 +66,8 @@ int main(int, char**) {
assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin() + 1));
assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin()));
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
using R = std::pair<M::iterator, M::iterator>;
@@ -85,5 +87,6 @@ int main(int, char**) {
assert(m.equal_range(true) == std::pair(m.begin(), m.begin()));
assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
index 32a9c2d2f74169..83362d379f47d7 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
@@ -60,6 +60,8 @@ int main(int, char**) {
assert(std::as_const(m).find(9) == m.end());
}
#endif
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
M m = {{true, false}, {false, true}};
@@ -77,5 +79,6 @@ int main(int, char**) {
assert(m.find(true) == m.end());
assert(m.find(false) == m.end());
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
index 1e697a1c02ed5b..2a62ce34603d4c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
@@ -60,6 +60,8 @@ int main(int, char**) {
assert(std::as_const(m).lower_bound(8) == m.begin());
assert(std::as_const(m).lower_bound(9) == m.begin());
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
M m = {{true, false}, {false, true}};
@@ -77,5 +79,6 @@ int main(int, char**) {
assert(m.lower_bound(true) == m.end());
assert(m.lower_bound(false) == m.end());
}
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
index 4058bdd4b6f3d3..29a0a63179caa1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
@@ -60,6 +60,8 @@ int main(int, char**) {
assert(std::as_const(m).upper_bound(8) == m.begin() + 1);
assert(std::as_const(m).upper_bound(9) == m.begin());
}
+#if 0
+ // vector<bool> is not supported
{
using M = std::flat_map<bool, bool>;
M m = {{true, false}, {false, true}};
@@ -77,5 +79,6 @@ int main(int, char**) {
assert(m.upper_bound(true) == m.end());
assert(m.upper_bound(false) == m.end());
}
+#endif
return 0;
}
>From bb6762662e818a6d42fd76ce1fa45a3f1c3dad8c Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 22 Sep 2024 11:04:58 +0100
Subject: [PATCH 18/40] comments
---
libcxx/include/__flat_map/flat_map.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index d6203bd6ac3184..72187a52aa5da5 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -1177,6 +1177,7 @@ class flat_map {
struct __key_equiv {
__key_equiv(key_compare __c) : __comp_(__c) {}
bool operator()(const_reference __x, const_reference __y) const {
+ // todo
// LWG issue ? spec uses __x.first but zip_view no longer uses pair
return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
}
>From 0ab32753becc84647d41b9f2d73c8265a64f71d6 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 22 Sep 2024 21:20:03 +0100
Subject: [PATCH 19/40] exception tests
---
libcxx/include/__flat_map/flat_map.h | 2 +-
.../flat.map.modifiers/emplace.pass.cpp | 130 ++++++++++++++++++
.../container.adaptors/flat.map/helpers.h | 56 ++++++++
3 files changed, 187 insertions(+), 1 deletion(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 72187a52aa5da5..f8605d2c13e52d 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -1115,7 +1115,7 @@ class flat_map {
__on_key_failed.__complete();
auto __on_value_failed = std::__make_exception_guard([&]() noexcept {
- if constexpr (!__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) {
+ if constexpr (!__container_traits<_MappedContainer>::__emplacement_has_strong_exception_safety_guarantee) {
// we need to clear both because we don't know the state of our values anymore
clear() /* noexcept */;
} else {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
index c4097781dbb226..cd76654ea12e91 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
@@ -18,6 +18,7 @@
#include <deque>
#include <tuple>
+#include "../helpers.h"
#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
@@ -118,6 +119,135 @@ int main(int, char**) {
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ {
+ // Throw on emplace the key, and underlying has strong exception guarantee
+ using M = std::flat_map<CopyableThrowOnMove, int>;
+ std::vector<CopyableThrowOnMove> a;
+ a.reserve(4);
+ a.emplace_back(1);
+ a.emplace_back(2);
+ a.emplace_back(3);
+ a.emplace_back(4);
+
+ std::vector<int> b = {5, 6, 7, 8};
+ [[maybe_unused]] auto expected_keys = a;
+ [[maybe_unused]] auto expected_values = b;
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ try {
+ m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is unchanged
+ LIBCPP_ASSERT(m.size() == 4);
+ LIBCPP_ASSERT(m.keys() == expected_keys);
+ LIBCPP_ASSERT(m.values() == expected_values);
+ }
+ }
+ {
+ // Throw on emplace the key, and underlying has no strong exception guarantee
+ using M = std::flat_map<MoveOnlyThrowOnMove, int>;
+ std::vector<MoveOnlyThrowOnMove> a;
+ a.reserve(4);
+ a.emplace_back(1);
+ a.emplace_back(2);
+ a.emplace_back(3);
+ a.emplace_back(4);
+
+ std::vector<int> b = {5, 6, 7, 8};
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ try {
+ m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is cleared
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+ {
+ // Throw on emplace the value, and underlying has strong exception guarantee
+ using M = std::flat_map<int, CopyableThrowOnMove>;
+ std::vector<int> a = {1, 2, 3, 4};
+ std::vector<CopyableThrowOnMove> b;
+ b.reserve(4);
+ b.emplace_back(1);
+ b.emplace_back(2);
+ b.emplace_back(3);
+ b.emplace_back(4);
+
+ [[maybe_unused]] auto expected_keys = a;
+ [[maybe_unused]] auto expected_values = b;
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ try {
+ m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the emplaced key is erased and the flat_map is unchanged
+ LIBCPP_ASSERT(m.size() == 4);
+ LIBCPP_ASSERT(m.keys() == expected_keys);
+ LIBCPP_ASSERT(m.values() == expected_values);
+ }
+ }
+ {
+ // Throw on emplace the value, and underlying has no strong exception guarantee
+ using M = std::flat_map<int, MoveOnlyThrowOnMove>;
+ std::vector<int> a = {1, 2, 3, 4};
+ std::vector<MoveOnlyThrowOnMove> b;
+ b.reserve(4);
+ b.emplace_back(1);
+ b.emplace_back(2);
+ b.emplace_back(3);
+ b.emplace_back(4);
+
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ try {
+ m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is unchanged
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+ {
+ using M = std::flat_map<ThrowOnSecondMove, CopyableThrowOnMove>;
+ std::vector<ThrowOnSecondMove> a;
+ a.reserve(4);
+ a.emplace_back(1);
+ a.emplace_back(2);
+ a.emplace_back(3);
+ a.emplace_back(4);
+
+ std::vector<CopyableThrowOnMove> b;
+ b.reserve(4);
+ b.emplace_back(1);
+ b.emplace_back(2);
+ b.emplace_back(3);
+ b.emplace_back(4);
+
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ try {
+ m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we try to erase the key after value emplacement failure.
+ // and after erasure failure, we clear the flat_map
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 0a3044cade7c4c..236671fd5b3186 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -9,10 +9,13 @@
#ifndef SUPPORT_FLAT_MAP_HELPERS_H
#define SUPPORT_FLAT_MAP_HELPERS_H
+#include <algorithm>
#include <cassert>
#include <string>
#include <vector>
+#include "test_macros.h"
+
struct StartsWith {
explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {}
StartsWith(const StartsWith&) = delete;
@@ -95,5 +98,58 @@ struct NoDefaultCtr {
NoDefaultCtr() = delete;
};
+template <bool Copyable = true>
+struct ThrowOnMove {
+ int i;
+ ThrowOnMove(int ii) : i(ii) {}
+ ThrowOnMove(const ThrowOnMove&)
+ requires Copyable
+ = default;
+
+ ThrowOnMove& operator=(const ThrowOnMove&)
+ requires Copyable
+ = default;
+
+ ThrowOnMove(ThrowOnMove&&) { throw 42; }
+
+ ThrowOnMove& operator=(ThrowOnMove&& other) {
+ other.i = -1;
+ throw 42;
+ }
+
+ friend bool operator==(const ThrowOnMove&, const ThrowOnMove&) = default;
+ friend auto operator<=>(const ThrowOnMove&, const ThrowOnMove&) = default;
+};
+
+using CopyableThrowOnMove = ThrowOnMove<true>;
+using MoveOnlyThrowOnMove = ThrowOnMove<false>;
+
+struct ThrowOnSecondMove {
+ int i;
+ int count;
+ ThrowOnSecondMove(int ii) : i(ii), count(0) {}
+ ThrowOnSecondMove(const ThrowOnSecondMove&) = delete;
+ ThrowOnSecondMove& operator=(const ThrowOnSecondMove&) = delete;
+
+ ThrowOnSecondMove(ThrowOnSecondMove&& other) : i(other.i), count(other.count) {
+ if (++count > 1)
+ throw 42;
+ }
+
+ ThrowOnSecondMove& operator=(ThrowOnSecondMove&&) {
+ if (++count > 1)
+ throw 42;
+ return *this;
+ }
+
+ friend bool operator==(const ThrowOnSecondMove&, const ThrowOnSecondMove&) = default;
+ friend auto operator<=>(const ThrowOnSecondMove&, const ThrowOnSecondMove&) = default;
+};
+
+template <class T, class Compare = std::less<>>
+bool is_sorted_and_unique(T&& container, Compare compare = Compare()) {
+ auto greater_or_equal_to = [&](const auto& x, const auto& y) { return !compare(x, y); };
+ return std::ranges::adjacent_find(container, greater_or_equal_to) == std::ranges::end(container);
+}
#endif // SUPPORT_FLAT_MAP_HELPERS_H
>From ced3a466f952c7d4e23390a7a5802582cea8942c Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 27 Sep 2024 17:15:18 +0100
Subject: [PATCH 20/40] more tests
---
libcxx/include/__flat_map/flat_map.h | 87 +++--
.../flat.map.access/at_transparent.pass.cpp | 8 +
.../flat.map.access/index_key.pass.cpp | 9 +
.../flat.map.access/index_rv_key.pass.cpp | 9 +
.../index_transparent.pass.cpp | 18 +-
.../flat.map.modifiers/clear.pass.cpp | 12 +
.../flat.map.modifiers/emplace.pass.cpp | 130 +------
.../flat.map.modifiers/emplace_hint.pass.cpp | 8 +
.../flat.map.modifiers/erase_iter.pass.cpp | 249 ++++++++++++
.../erase_iter_iter.pass.cpp | 168 ++++++++
.../flat.map.modifiers/erase_key.pass.cpp | 11 +
.../erase_key_transparent.pass.cpp | 18 +
.../flat.map.modifiers/extract.pass.cpp | 21 +
.../flat.map.modifiers/insert_cv.pass.cpp | 10 +
.../insert_initializer_list.pass.cpp | 10 +
.../insert_iter_cv.pass.cpp | 10 +
.../insert_iter_iter.pass.cpp | 5 +
.../insert_iter_rv.pass.cpp | 11 +
.../insert_or_assign.pass.cpp | 304 +++++++++++++++
.../insert_or_assign_transparent.pass.cpp | 250 ++++++++++++
.../flat.map.modifiers/insert_range.pass.cpp | 5 +
.../flat.map.modifiers/insert_rv.pass.cpp | 10 +
.../insert_sorted_initializer_list.pass.cpp | 10 +
.../insert_sorted_iter_iter.pass.cpp | 7 +
.../insert_transparent.pass.cpp | 31 +-
.../flat.map.modifiers/replace.pass.cpp | 68 ++++
.../flat.map.modifiers/swap_free.pass.cpp | 135 +++++++
.../flat.map.modifiers/swap_member.pass.cpp | 135 +++++++
.../flat.map.modifiers/try_emplace.pass.cpp | 225 +++++++++++
.../try_emplace_transparent.pass.cpp | 170 ++++++++
.../flat.map.observers/keys_values.pass.cpp | 64 +++
.../contains_transparent.pass.cpp | 9 +
.../count_transparent.pass.cpp | 9 +
.../equal_range_transparent.pass.cpp | 9 +
.../find_transparent.pass.cpp | 9 +
.../lower_bound_transparent.pass.cpp | 9 +
.../upper_bound_transparent.pass.cpp | 9 +
.../container.adaptors/flat.map/helpers.h | 363 ++++++++++++++++--
38 files changed, 2423 insertions(+), 202 deletions(-)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index f8605d2c13e52d..73d2c457ef1f58 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -21,6 +21,7 @@
#include <__algorithm/ranges_upper_bound.h>
#include <__compare/synth_three_way.h>
#include <__concepts/convertible_to.h>
+#include <__concepts/swappable.h>
#include <__config>
#include <__flat_map/container_traits.h>
#include <__flat_map/sorted_unique.h>
@@ -539,8 +540,8 @@ class flat_map {
}
template <class _Kp>
- requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type> &&
- is_convertible_v<_Kp&&, const_iterator> && is_convertible_v<_Kp&&, iterator>
+ requires(__is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type> &&
+ !is_convertible_v<_Kp &&, const_iterator> && !is_convertible_v<_Kp &&, iterator>)
_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](_Kp&& __x) {
return try_emplace(std::forward<_Kp>(__x)).first->second;
}
@@ -597,7 +598,7 @@ class flat_map {
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
- return __try_emplace_hint(__hint, std::move(__pair.first), std::move(__pair.second));
+ return __try_emplace_hint(__hint, std::move(__pair.first), std::move(__pair.second)).first;
}
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return emplace(__x); }
@@ -689,9 +690,9 @@ class flat_map {
}
template <class _Kp, class... _Args>
- requires __is_compare_transparent && is_constructible_v<key_type, _Kp> &&
- is_constructible_v<mapped_type, _Args...> && is_convertible_v<_Kp&&, const_iterator> &&
- is_convertible_v<_Kp&&, iterator>
+ requires(__is_compare_transparent && is_constructible_v<key_type, _Kp> &&
+ is_constructible_v<mapped_type, _Args...> && !is_convertible_v<_Kp &&, const_iterator> &&
+ !is_convertible_v<_Kp &&, iterator>)
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(_Kp&& __key, _Args&&... __args) {
return __try_emplace(std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
}
@@ -699,57 +700,57 @@ class flat_map {
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, const key_type& __key, _Args&&... __args) {
- return __try_emplace_hint(__hint, __key, std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, __key, std::forward<_Args>(__args)...).first;
}
template <class... _Args>
requires is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, key_type&& __key, _Args&&... __args) {
- return __try_emplace_hint(__hint, std::move(__key), std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, std::move(__key), std::forward<_Args>(__args)...).first;
}
template <class _Kp, class... _Args>
requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_constructible_v<mapped_type, _Args...>
_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
- return __try_emplace_hint(__hint, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ return __try_emplace_hint(__hint, std::forward<_Kp>(__key), std::forward<_Args>(__args)...).first;
}
template <class _Mapped>
requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(__key, std::forward<_Mapped>(__obj));
+ return __insert_or_assign(__key, std::forward<_Mapped>(__obj));
}
template <class _Mapped>
requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(std::move(__key), std::forward<_Mapped>(__obj));
+ return __insert_or_assign(std::move(__key), std::forward<_Mapped>(__obj));
}
template <class _Kp, class _Mapped>
requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_assignable_v<mapped_type&, _Mapped> &&
is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(_Kp&& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(std::forward<_Kp>(__key), std::forward<_Mapped>(__obj));
+ return __insert_or_assign(std::forward<_Kp>(__key), std::forward<_Mapped>(__obj));
}
template <class _Mapped>
requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, const key_type& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(__key, std::forward<_Mapped>(__obj), __hint).first;
+ return __insert_or_assign(__hint, __key, std::forward<_Mapped>(__obj));
}
template <class _Mapped>
requires is_assignable_v<mapped_type&, _Mapped> && is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, key_type&& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(std::move(__key), std::forward<_Mapped>(__obj), __hint).first;
+ return __insert_or_assign(__hint, std::move(__key), std::forward<_Mapped>(__obj));
}
template <class _Kp, class _Mapped>
requires __is_compare_transparent && is_constructible_v<key_type, _Kp> && is_assignable_v<mapped_type&, _Mapped> &&
is_constructible_v<mapped_type, _Mapped>
_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __hint, _Kp&& __key, _Mapped&& __obj) {
- return __insert_or_assign_impl(std::forward<_Kp>(__key), std::forward<_Mapped>(__obj), __hint).first;
+ return __insert_or_assign(__hint, std::forward<_Kp>(__key), std::forward<_Mapped>(__obj));
}
_LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
@@ -788,15 +789,20 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
- auto __guard = std::__make_exception_guard([&]() noexcept {
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ try {
+# endif
+ ranges::swap(__compare_, __y.__compare_);
+ ranges::swap(__containers_.keys, __y.__containers_.keys);
+ ranges::swap(__containers_.values, __y.__containers_.values);
+# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+ } catch (...) {
+ // todo: how can we tell the user that the swap is unsuccessful?
+ // need to swallow the exception because the function is noexcept
clear() /* noexcept */;
__y.clear() /*noexcept*/;
- });
- using std::swap;
- swap(__compare_, __y.__compare_);
- swap(__containers_.keys, __y.__containers_.keys);
- swap(__containers_.values, __y.__containers_.values);
- __guard.__complete();
+ }
+# endif
}
_LIBCPP_HIDE_FROM_ABI void clear() noexcept {
@@ -807,6 +813,8 @@ class flat_map {
// observers
_LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; }
_LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__compare_); }
+
+ // todo: can flat_map | std::views::keys be specialised?
_LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; }
_LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; }
@@ -912,10 +920,10 @@ class flat_map {
private:
struct __ctor_uses_allocator_tag {
- explicit __ctor_uses_allocator_tag() = default;
+ explicit _LIBCPP_HIDE_FROM_ABI __ctor_uses_allocator_tag() = default;
};
struct __ctor_uses_allocator_empty_tag {
- explicit __ctor_uses_allocator_empty_tag() = default;
+ explicit _LIBCPP_HIDE_FROM_ABI __ctor_uses_allocator_empty_tag() = default;
};
template <class _Allocator, class _KeyCont, class _MappedCont, class... _CompArg>
@@ -1085,18 +1093,20 @@ class flat_map {
}
template <class _Kp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI iterator __try_emplace_hint(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __try_emplace_hint(const_iterator __hint, _Kp&& __key, _Args&&... __args) {
if (__is_hint_correct(__hint, __key)) {
if (__hint == cend() || __compare_(__key, __hint->first)) {
- return __try_emplace_exact_hint(
- __hint.__key_iter_, __hint.__mapped_iter_, std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
+ return {
+ __try_emplace_exact_hint(
+ __hint.__key_iter_, __hint.__mapped_iter_, std::forward<_Kp>(__key), std::forward<_Args>(__args)...),
+ true};
} else {
// key equals
auto __dist = __hint - cbegin();
- return iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist);
+ return {iterator(__containers_.keys.begin() + __dist, __containers_.values.begin() + __dist), false};
}
} else {
- return __try_emplace(std::forward<_Kp>(__key), std::forward<_Args>(__args)...).first;
+ return __try_emplace(std::forward<_Kp>(__key), std::forward<_Args>(__args)...);
}
}
@@ -1139,15 +1149,24 @@ class flat_map {
return iterator(std::move(__key_it), std::move(__mapped_it));
}
- template <class _Kp, class _Mapped, class... _Hint>
- _LIBCPP_HIDE_FROM_ABI auto __insert_or_assign_impl(_Kp&& __key, _Mapped&& __mapped, _Hint&&... __hint) {
- auto __r = try_emplace(__hint..., std::forward<_Kp>(__key), std::forward<_Mapped>(__mapped));
+ template <class _Kp, class _Mapped>
+ _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_or_assign(_Kp&& __key, _Mapped&& __mapped) {
+ auto __r = try_emplace(std::forward<_Kp>(__key), std::forward<_Mapped>(__mapped));
if (!__r.second) {
__r.first->second = std::forward<_Mapped>(__mapped);
}
return __r;
}
+ template <class _Kp, class _Mapped>
+ _LIBCPP_HIDE_FROM_ABI iterator __insert_or_assign(const_iterator __hint, _Kp&& __key, _Mapped&& __mapped) {
+ auto __r = __try_emplace_hint(__hint, std::forward<_Kp>(__key), std::forward<_Mapped>(__mapped));
+ if (!__r.second) {
+ __r.first->second = std::forward<_Mapped>(__mapped);
+ }
+ return __r.first;
+ }
+
_LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) {
if constexpr (requires { __containers_.keys.reserve(__size); }) {
__containers_.keys.reserve(__size);
@@ -1175,8 +1194,8 @@ class flat_map {
[[no_unique_address]] key_compare __compare_;
struct __key_equiv {
- __key_equiv(key_compare __c) : __comp_(__c) {}
- bool operator()(const_reference __x, const_reference __y) const {
+ _LIBCPP_HIDE_FROM_ABI __key_equiv(key_compare __c) : __comp_(__c) {}
+ _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
// todo
// LWG issue ? spec uses __x.first but zip_view no longer uses pair
return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
index 32477bb25a4976..2bb6c6d02a048c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
@@ -138,6 +138,14 @@ int main(int, char**) {
assert(m.at(Transparent<int>{8}) == 8.5);
assert(m.size() == 7);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ m.at(Transparent<int>{3});
+ assert(transparent_used);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
index 45625d00d495be..245c87e32227f5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
@@ -91,5 +91,14 @@ int main(int, char**) {
assert(m.size() == 8);
}
+ {
+ auto index_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ const typename FlatMap::key_type key = key_arg;
+ const typename FlatMap::mapped_type value = value_arg;
+ m[key] = value;
+ };
+ test_emplace_exception_guarantee(index_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
index a3d34feca752d2..0d2c38e805ce62 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
@@ -65,5 +65,14 @@ int main(int, char**) {
assert(m.size() == 2);
}
+ {
+ auto index_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ typename FlatMap::key_type key = key_arg;
+ const typename FlatMap::mapped_type value = value_arg;
+ m[std::move(key)] = value;
+ };
+ test_emplace_exception_guarantee(index_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
index fb37a175cacb48..e23befc0c15d2d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
@@ -109,6 +109,22 @@ int main(int, char**) {
assert(m[six] == 6.5);
assert(m.size() == 8);
}
-
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ m[ConvertibleTransparent<int>{3}];
+ assert(transparent_used);
+ }
+ {
+ auto index_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using Key = typename FlatMap::key_type;
+ const typename FlatMap::mapped_type value = value_arg;
+ m[ConvertibleTransparent<Key>{key_arg}] = value;
+ };
+ test_emplace_exception_guarantee(index_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
index 9595ac202a0e2e..c3562013470aeb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
@@ -20,9 +20,21 @@
#include <functional>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+// test noexcept
+
+template <class T>
+concept NoExceptClear = requires(T t) {
+ { t.clear() } noexcept;
+};
+
+static_assert(NoExceptClear<std::flat_map<int, int>>);
+static_assert(
+ NoExceptClear<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+
int main(int, char**) {
{
using M = std::flat_map<int, int>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
index cd76654ea12e91..cfcc786e61edbb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
@@ -119,135 +119,13 @@ int main(int, char**) {
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
-#ifndef TEST_HAS_NO_EXCEPTIONS
- {
- // Throw on emplace the key, and underlying has strong exception guarantee
- using M = std::flat_map<CopyableThrowOnMove, int>;
- std::vector<CopyableThrowOnMove> a;
- a.reserve(4);
- a.emplace_back(1);
- a.emplace_back(2);
- a.emplace_back(3);
- a.emplace_back(4);
-
- std::vector<int> b = {5, 6, 7, 8};
- [[maybe_unused]] auto expected_keys = a;
- [[maybe_unused]] auto expected_values = b;
- M m(std::sorted_unique, std::move(a), std::move(b));
-
- try {
- m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
- assert(false);
- } catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
- // In libc++, the flat_map is unchanged
- LIBCPP_ASSERT(m.size() == 4);
- LIBCPP_ASSERT(m.keys() == expected_keys);
- LIBCPP_ASSERT(m.values() == expected_values);
- }
- }
- {
- // Throw on emplace the key, and underlying has no strong exception guarantee
- using M = std::flat_map<MoveOnlyThrowOnMove, int>;
- std::vector<MoveOnlyThrowOnMove> a;
- a.reserve(4);
- a.emplace_back(1);
- a.emplace_back(2);
- a.emplace_back(3);
- a.emplace_back(4);
-
- std::vector<int> b = {5, 6, 7, 8};
- M m(std::sorted_unique, std::move(a), std::move(b));
- try {
- m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
- assert(false);
- } catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
- // In libc++, the flat_map is cleared
- LIBCPP_ASSERT(m.size() == 0);
- }
- }
- {
- // Throw on emplace the value, and underlying has strong exception guarantee
- using M = std::flat_map<int, CopyableThrowOnMove>;
- std::vector<int> a = {1, 2, 3, 4};
- std::vector<CopyableThrowOnMove> b;
- b.reserve(4);
- b.emplace_back(1);
- b.emplace_back(2);
- b.emplace_back(3);
- b.emplace_back(4);
- [[maybe_unused]] auto expected_keys = a;
- [[maybe_unused]] auto expected_values = b;
- M m(std::sorted_unique, std::move(a), std::move(b));
-
- try {
- m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
- assert(false);
- } catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
- // In libc++, the emplaced key is erased and the flat_map is unchanged
- LIBCPP_ASSERT(m.size() == 4);
- LIBCPP_ASSERT(m.keys() == expected_keys);
- LIBCPP_ASSERT(m.values() == expected_values);
- }
- }
- {
- // Throw on emplace the value, and underlying has no strong exception guarantee
- using M = std::flat_map<int, MoveOnlyThrowOnMove>;
- std::vector<int> a = {1, 2, 3, 4};
- std::vector<MoveOnlyThrowOnMove> b;
- b.reserve(4);
- b.emplace_back(1);
- b.emplace_back(2);
- b.emplace_back(3);
- b.emplace_back(4);
-
- M m(std::sorted_unique, std::move(a), std::move(b));
-
- try {
- m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
- assert(false);
- } catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
- // In libc++, the flat_map is unchanged
- LIBCPP_ASSERT(m.size() == 0);
- }
- }
{
- using M = std::flat_map<ThrowOnSecondMove, CopyableThrowOnMove>;
- std::vector<ThrowOnSecondMove> a;
- a.reserve(4);
- a.emplace_back(1);
- a.emplace_back(2);
- a.emplace_back(3);
- a.emplace_back(4);
-
- std::vector<CopyableThrowOnMove> b;
- b.reserve(4);
- b.emplace_back(1);
- b.emplace_back(2);
- b.emplace_back(3);
- b.emplace_back(4);
-
- M m(std::sorted_unique, std::move(a), std::move(b));
- try {
- m.emplace(std::piecewise_construct, std::tuple(0), std::tuple(0));
- assert(false);
- } catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
- // In libc++, we try to erase the key after value emplacement failure.
- // and after erasure failure, we clear the flat_map
- LIBCPP_ASSERT(m.size() == 0);
- }
+ auto emplace_func = [](auto& m, auto key_arg, auto value_arg) {
+ m.emplace(std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ };
+ test_emplace_exception_guarantee(emplace_func);
}
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
index 315d3f4fc58061..bad175e299d37b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
@@ -21,6 +21,7 @@
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
#include "min_allocator.h"
+#include "../helpers.h"
#if defined(_LIBCPP_VERSION)
// spec only specifies `emplace(Args&&...)` is_constructible_v<pair<key_type, mapped_type>, Args...> is true.
@@ -113,5 +114,12 @@ int main(int, char**) {
assert(m.begin()->second == 3.5);
}
+ {
+ auto emplace_func = [](auto& m, auto key_arg, auto value_arg) {
+ m.emplace_hint(m.begin(), std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ };
+ test_emplace_exception_guarantee(emplace_func);
+ }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
new file mode 100644
index 00000000000000..8799caf83f4bec
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
@@ -0,0 +1,249 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator erase(iterator position);
+// iterator erase(const_iterator position);
+
+#include <compare>
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, double>;
+ using P = std::pair<int, double>;
+ using I = typename M::iterator;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3));
+ assert(m.size() == 7);
+ assert(i1 == std::next(m.begin(), 3));
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 5);
+ assert(std::next(m.begin(), 3)->second == 5.5);
+ assert(std::next(m.begin(), 4)->first == 6);
+ assert(std::next(m.begin(), 4)->second == 6.5);
+ assert(std::next(m.begin(), 5)->first == 7);
+ assert(std::next(m.begin(), 5)->second == 7.5);
+ assert(std::next(m.begin(), 6)->first == 8);
+ assert(std::next(m.begin(), 6)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5));
+ assert(m.size() == 5);
+ assert(i3 == m.end());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
+ assert(m.size() == 4);
+ assert(i4 == std::next(m.begin()));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 6);
+ assert(std::next(m.begin(), 2)->second == 6.5);
+ assert(std::next(m.begin(), 3)->first == 7);
+ assert(std::next(m.begin(), 3)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
+ assert(m.size() == 3);
+ assert(i5 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 7);
+ assert(std::next(m.begin(), 2)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
+ assert(m.size() == 2);
+ assert(i6 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+
+ std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
+ assert(m.size() == 1);
+ assert(i7 == std::next(m.begin(), 0));
+ assert(m.begin()->first == 5);
+ assert(m.begin()->second == 5.5);
+
+ std::same_as<I> decltype(auto) i8 = m.erase(m.begin());
+ assert(m.size() == 0);
+ assert(i8 == m.begin());
+ assert(i8 == m.end());
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>;
+ using P = std::pair<int, double>;
+ using I = typename M::iterator;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3));
+ assert(m.size() == 7);
+ assert(i1 == std::next(m.begin(), 3));
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 5);
+ assert(std::next(m.begin(), 3)->second == 5.5);
+ assert(std::next(m.begin(), 4)->first == 6);
+ assert(std::next(m.begin(), 4)->second == 6.5);
+ assert(std::next(m.begin(), 5)->first == 7);
+ assert(std::next(m.begin(), 5)->second == 7.5);
+ assert(std::next(m.begin(), 6)->first == 8);
+ assert(std::next(m.begin(), 6)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5));
+ assert(m.size() == 5);
+ assert(i3 == m.end());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
+ assert(m.size() == 4);
+ assert(i4 == std::next(m.begin()));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 6);
+ assert(std::next(m.begin(), 2)->second == 6.5);
+ assert(std::next(m.begin(), 3)->first == 7);
+ assert(std::next(m.begin(), 3)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
+ assert(m.size() == 3);
+ assert(i5 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 7);
+ assert(std::next(m.begin(), 2)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
+ assert(m.size() == 2);
+ assert(i6 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+
+ std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
+ assert(m.size() == 1);
+ assert(i7 == std::next(m.begin(), 0));
+ assert(m.begin()->first == 5);
+ assert(m.begin()->second == 5.5);
+
+ std::same_as<I> decltype(auto) i8 = m.erase(m.begin());
+ assert(m.size() == 0);
+ assert(i8 == m.begin());
+ assert(i8 == m.end());
+ }
+ {
+ auto erase_function = [](auto& m, auto) { m.erase(m.begin() + 2); };
+ test_erase_exception_guarantee(erase_function);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
new file mode 100644
index 00000000000000..3ac2115e716e86
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
@@ -0,0 +1,168 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// iterator erase(const_iterator first, const_iterator last);
+
+#include <compare>
+#include <concepts>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <utility>
+
+#include "../helpers.h"
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, double>;
+ using P = std::pair<int, double>;
+ using I = M::iterator;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin());
+ assert(m.size() == 8);
+ assert(i1 == m.begin());
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 4);
+ assert(std::next(m.begin(), 3)->second == 4.5);
+ assert(std::next(m.begin(), 4)->first == 5);
+ assert(std::next(m.begin(), 4)->second == 5.5);
+ assert(std::next(m.begin(), 5)->first == 6);
+ assert(std::next(m.begin(), 5)->second == 6.5);
+ assert(std::next(m.begin(), 6)->first == 7);
+ assert(std::next(m.begin(), 6)->second == 7.5);
+ assert(std::next(m.begin(), 7)->first == 8);
+ assert(std::next(m.begin(), 7)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6));
+ assert(m.size() == 2);
+ assert(i3 == std::next(m.begin(), 2));
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
+
+ std::same_as<I> decltype(auto) i4 = m.erase(m.cbegin(), m.cend());
+ assert(m.size() == 0);
+ assert(i4 == m.begin());
+ assert(i4 == m.end());
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>;
+ using P = std::pair<int, double>;
+ using I = typename M::iterator;
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin());
+ assert(m.size() == 8);
+ assert(i1 == m.begin());
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 4);
+ assert(std::next(m.begin(), 3)->second == 4.5);
+ assert(std::next(m.begin(), 4)->first == 5);
+ assert(std::next(m.begin(), 4)->second == 5.5);
+ assert(std::next(m.begin(), 5)->first == 6);
+ assert(std::next(m.begin(), 5)->second == 6.5);
+ assert(std::next(m.begin(), 6)->first == 7);
+ assert(std::next(m.begin(), 6)->second == 7.5);
+ assert(std::next(m.begin(), 7)->first == 8);
+ assert(std::next(m.begin(), 7)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6));
+ assert(m.size() == 2);
+ assert(i3 == std::next(m.begin(), 2));
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
+
+ std::same_as<I> decltype(auto) i4 = m.erase(m.cbegin(), m.cend());
+ assert(m.size() == 0);
+ assert(i4 == m.begin());
+ assert(i4 == m.end());
+ }
+
+ {
+ auto erase_function = [](auto& m, auto) { m.erase(m.begin(), m.begin() + 2); };
+ test_erase_exception_guarantee(erase_function);
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
index 50dd566b0b7f5e..d23801d0689e67 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
@@ -19,6 +19,7 @@
#include <functional>
#include <utility>
+#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -109,5 +110,15 @@ int main(int, char**) {
assert(n == 1);
assert(m.empty());
}
+ {
+ auto erase_function = [](auto& m, auto key_arg) {
+ using Map = std::decay_t<decltype(m)>;
+ using Key = typename Map::key_type;
+ const Key key{key_arg};
+ m.erase(key);
+ };
+ test_erase_exception_guarantee(erase_function);
+ }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
index 5f3a92884cd15c..296e8c2da41611 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
@@ -132,5 +132,23 @@ int main(int, char**) {
assert(it == m.begin());
assert((m == M{{2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}}));
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto n = m.erase(Transparent<int>{3});
+ assert(n == 1);
+ assert(transparent_used);
+ }
+ {
+ auto erase_transparent = [](auto& m, auto key_arg) {
+ using Map = std::decay_t<decltype(m)>;
+ using Key = typename Map::key_type;
+ m.erase(Transparent<Key>{key_arg});
+ };
+ test_erase_exception_guarantee(erase_transparent);
+ }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
index 9996f2a74ae40d..8a3d37c170b503 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
@@ -53,5 +53,26 @@ int main(int, char**) {
LIBCPP_ASSERT(m.values().size() == 0);
}
+ {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ using KeyContainer = std::vector<int>;
+ using ValueContainer = ThrowOnMoveContainer<int>;
+ using M = std::flat_map<int, int, std::ranges::less, KeyContainer, ValueContainer>;
+
+ M m;
+ m.emplace(1, 1);
+ m.emplace(2, 2);
+ try {
+ auto c = std::move(m).extract();
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we try to erase the key after value emplacement failure.
+ // and after erasure failure, we clear the flat_map
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+#endif
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
index 6016b86e3421f5..4ed8bba7731d56 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
@@ -18,6 +18,7 @@
#include <deque>
#include "test_macros.h"
+#include "../helpers.h"
#include "min_allocator.h"
template <class Container>
@@ -71,5 +72,14 @@ int main(int, char**) {
std::deque<double, min_allocator<double>>>;
do_insert_cv_test<M>();
}
+ {
+ auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ const value_type p(std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ m.insert(p);
+ };
+ test_emplace_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
index e86a3a7e6f106a..55e12c724ed293 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
@@ -17,6 +17,7 @@
#include <functional>
#include <deque>
+#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -73,5 +74,14 @@ int main(int, char**) {
assert(*std::next(m.begin(), 3) == V(4, 1));
}
+ {
+ auto insert_func = [](auto& m, const auto& newValues) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ std::initializer_list<value_type> il = {{newValues[0].first, newValues[0].second}};
+ m.insert(il);
+ };
+ test_insert_range_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
index 8bccec486e0cfe..a0095b831193b6 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
@@ -18,6 +18,7 @@
#include <deque>
#include "test_macros.h"
+#include "../helpers.h"
#include "min_allocator.h"
template <class Container>
@@ -68,5 +69,14 @@ int main(int, char**) {
do_insert_iter_cv_test<M>();
}
+ {
+ auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ const value_type p(std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ m.insert(m.begin(), p);
+ };
+ test_emplace_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
index 835cad4c4ad928..d30703c3d6d76d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
@@ -18,6 +18,7 @@
#include <functional>
#include <deque>
+#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
@@ -89,5 +90,9 @@ int main(int, char**) {
assert(m == expected2);
}
+ {
+ auto insert_func = [](auto& m, const auto& newValues) { m.insert(newValues.begin(), newValues.end()); };
+ test_insert_range_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
index 3eab817a2f24d2..b782685c5de8bf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
@@ -17,6 +17,7 @@
#include "MoveOnly.h"
#include "min_allocator.h"
+#include "../helpers.h"
#include "test_macros.h"
template <class Container, class Pair>
@@ -94,5 +95,15 @@ int main(int, char**) {
assert(r->second == 3);
}
+ {
+ auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ value_type p(std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ m.insert(m.begin(), std::move(p));
+ };
+ test_emplace_exception_guarantee(insert_func);
+ }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
new file mode 100644
index 00000000000000..5a929f3b306799
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
@@ -0,0 +1,304 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+#include "../helpers.h"
+
+// template<class M>
+// pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+// template<class M>
+// pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+// template<class M>
+// iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
+// template<class M>
+// iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+
+// Constraints: is_assignable_v<mapped_type&, M> is true and is_constructible_v<mapped_type, M> is true.
+template <class Map, class K, class M>
+concept CanInsertOrAssign =
+ requires(Map map, K&& k, M&& m) { map.insert_or_assign(std::forward<K>(k), std::forward<M>(m)); };
+
+template <class Map, class K, class M>
+concept CanInsertOrAssignIter = requires(Map map, typename Map::const_iterator iter, K&& k, M&& m) {
+ map.insert_or_assign(iter, std::forward<K>(k), std::forward<M>(m));
+};
+
+template <class From>
+struct ConstructAndAssignFrom {
+ explicit ConstructAndAssignFrom(From);
+ ConstructAndAssignFrom& operator=(From);
+};
+
+template <class From>
+struct ConstructFrom {
+ explicit ConstructFrom(From);
+};
+
+template <class From>
+struct AssignFrom {
+ AssignFrom& operator=(From);
+};
+
+struct Value {};
+
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, int>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>>, const int&, Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>>, const int&, Value>);
+
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, int>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>>, int&&, Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>>, int&&, Value>);
+
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, int>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>>, const int&, Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>>, const int&, Value>);
+
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, int>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>>, int&&, Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>>, int&&, Value>);
+
+int main(int, char**) {
+ { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+ using M = std::flat_map<int, Moveable>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+
+ for (int i = 0; i < 20; i += 2) {
+ Moveable mv(i + 1, i + 1);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(i, std::move(mv));
+ assert(m.size() == 10);
+ assert(!r1.second); // was not inserted
+ assert(mv.moved()); // was moved from
+ assert(r1.first->first == i); // key
+ assert(r1.first->second.get() == i + 1); // value
+ }
+
+ Moveable mv1(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.insert_or_assign(-1, std::move(mv1));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv1.moved()); // was moved from
+ assert(r2.first->first == -1); // key
+ assert(r2.first->second.get() == 5); // value
+
+ Moveable mv2(9, 9.0);
+ std::same_as<R> decltype(auto) r3 = m.insert_or_assign(3, std::move(mv2));
+ assert(m.size() == 12);
+ assert(r3.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r3.first->first == 3); // key
+ assert(r3.first->second.get() == 9); // value
+
+ Moveable mv3(-1, 5.0);
+ std::same_as<R> decltype(auto) r4 = m.insert_or_assign(117, std::move(mv3));
+ assert(m.size() == 13);
+ assert(r4.second); // was inserted
+ assert(mv3.moved()); // was moved from
+ assert(r4.first->first == 117); // key
+ assert(r4.first->second.get() == -1); // value
+ }
+ { // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+ using M = std::flat_map<Moveable, Moveable>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
+ assert(m.size() == 10);
+
+ Moveable mvkey1(2, 2.0);
+ Moveable mv1(4, 4.0);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(std::move(mvkey1), std::move(mv1));
+ assert(m.size() == 10);
+ assert(!r1.second); // was not inserted
+ assert(!mvkey1.moved()); // was not moved from
+ assert(mv1.moved()); // was moved from
+ assert(r1.first->first == mvkey1); // key
+ assert(r1.first->second.get() == 4); // value
+
+ Moveable mvkey2(3, 3.0);
+ Moveable mv2(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(std::move(mvkey2), std::move(mv2));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(mvkey2.moved()); // was moved from
+ assert(r2.first->first.get() == 3); // key
+ assert(r2.first->second.get() == 5); // value
+ }
+ { // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
+ using M = std::flat_map<int, Moveable>;
+ M m;
+ using R = M::iterator;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+ M::const_iterator it = m.find(2);
+
+ Moveable mv1(3, 3.0);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(it, 2, std::move(mv1));
+ assert(m.size() == 10);
+ assert(mv1.moved()); // was moved from
+ assert(r1->first == 2); // key
+ assert(r1->second.get() == 3); // value
+
+ Moveable mv2(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.insert_or_assign(it, 3, std::move(mv2));
+ assert(m.size() == 11);
+ assert(mv2.moved()); // was moved from
+ assert(r2->first == 3); // key
+ assert(r2->second.get() == 5); // value
+
+ // wrong hint: begin()
+ Moveable mv3(7, 7.0);
+ std::same_as<R> decltype(auto) r3 = m.insert_or_assign(m.begin(), 4, std::move(mv3));
+ assert(m.size() == 11);
+ assert(mv3.moved()); // was moved from
+ assert(r3->first == 4); // key
+ assert(r3->second.get() == 7); // value
+
+ Moveable mv4(9, 9.0);
+ std::same_as<R> decltype(auto) r4 = m.insert_or_assign(m.begin(), 5, std::move(mv4));
+ assert(m.size() == 12);
+ assert(mv4.moved()); // was moved from
+ assert(r4->first == 5); // key
+ assert(r4->second.get() == 9); // value
+
+ // wrong hint: end()
+ Moveable mv5(11, 11.0);
+ std::same_as<R> decltype(auto) r5 = m.insert_or_assign(m.end(), 6, std::move(mv5));
+ assert(m.size() == 12);
+ assert(mv5.moved()); // was moved from
+ assert(r5->first == 6); // key
+ assert(r5->second.get() == 11); // value
+
+ Moveable mv6(13, 13.0);
+ std::same_as<R> decltype(auto) r6 = m.insert_or_assign(m.end(), 7, std::move(mv6));
+ assert(m.size() == 13);
+ assert(mv6.moved()); // was moved from
+ assert(r6->first == 7); // key
+ assert(r6->second.get() == 13); // value
+
+ // wrong hint: third element
+ Moveable mv7(15, 15.0);
+ std::same_as<R> decltype(auto) r7 = m.insert_or_assign(std::next(m.begin(), 2), 8, std::move(mv7));
+ assert(m.size() == 13);
+ assert(mv7.moved()); // was moved from
+ assert(r7->first == 8); // key
+ assert(r7->second.get() == 15); // value
+
+ Moveable mv8(17, 17.0);
+ std::same_as<R> decltype(auto) r8 = m.insert_or_assign(std::next(m.begin(), 2), 9, std::move(mv8));
+ assert(m.size() == 14);
+ assert(mv8.moved()); // was moved from
+ assert(r8->first == 9); // key
+ assert(r8->second.get() == 17); // value
+ }
+ { // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+ using M = std::flat_map<Moveable, Moveable>;
+ using R = M::iterator;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
+ assert(m.size() == 10);
+ M::const_iterator it = std::next(m.cbegin());
+
+ Moveable mvkey1(2, 2.0);
+ Moveable mv1(4, 4.0);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(it, std::move(mvkey1), std::move(mv1));
+ assert(m.size() == 10);
+ assert(mv1.moved()); // was moved from
+ assert(!mvkey1.moved()); // was not moved from
+ assert(r1->first == mvkey1); // key
+ assert(r1->second.get() == 4); // value
+
+ Moveable mvkey2(3, 3.0);
+ Moveable mv2(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.insert_or_assign(it, std::move(mvkey2), std::move(mv2));
+ assert(m.size() == 11);
+ assert(mv2.moved()); // was moved from
+ assert(mvkey2.moved()); // was moved from
+ assert(r2->first.get() == 3); // key
+ assert(r2->second.get() == 5); // value
+
+ // wrong hint: begin()
+ Moveable mvkey3(6, 6.0);
+ Moveable mv3(8, 8.0);
+ std::same_as<R> decltype(auto) r3 = m.insert_or_assign(m.begin(), std::move(mvkey3), std::move(mv3));
+ assert(m.size() == 11);
+ assert(mv3.moved()); // was moved from
+ assert(!mvkey3.moved()); // was not moved from
+ assert(r3->first == mvkey3); // key
+ assert(r3->second.get() == 8); // value
+
+ Moveable mvkey4(7, 7.0);
+ Moveable mv4(9, 9.0);
+ std::same_as<R> decltype(auto) r4 = m.insert_or_assign(m.begin(), std::move(mvkey4), std::move(mv4));
+ assert(m.size() == 12);
+ assert(mv4.moved()); // was moved from
+ assert(mvkey4.moved()); // was moved from
+ assert(r4->first.get() == 7); // key
+ assert(r4->second.get() == 9); // value
+
+ // wrong hint: end()
+ Moveable mvkey5(8, 8.0);
+ Moveable mv5(10, 10.0);
+ std::same_as<R> decltype(auto) r5 = m.insert_or_assign(m.end(), std::move(mvkey5), std::move(mv5));
+ assert(m.size() == 12);
+ assert(mv5.moved()); // was moved from
+ assert(!mvkey5.moved()); // was not moved from
+ assert(r5->first == mvkey5); // key
+ assert(r5->second.get() == 10); // value
+
+ Moveable mvkey6(9, 9.0);
+ Moveable mv6(11, 11.0);
+ std::same_as<R> decltype(auto) r6 = m.insert_or_assign(m.end(), std::move(mvkey6), std::move(mv6));
+ assert(m.size() == 13);
+ assert(mv6.moved()); // was moved from
+ assert(mvkey6.moved()); // was moved from
+ assert(r6->first.get() == 9); // key
+ assert(r6->second.get() == 11); // value
+
+ // wrong hint: third element
+ Moveable mvkey7(10, 10.0);
+ Moveable mv7(12, 12.0);
+ std::same_as<R> decltype(auto) r7 = m.insert_or_assign(std::next(m.begin(), 2), std::move(mvkey7), std::move(mv7));
+ assert(m.size() == 13);
+ assert(mv7.moved()); // was moved from
+ assert(!mvkey7.moved()); // was not moved from
+ assert(r7->first == mvkey7); // key
+ assert(r7->second.get() == 12); // value
+
+ Moveable mvkey8(11, 11.0);
+ Moveable mv8(13, 13.0);
+ std::same_as<R> decltype(auto) r8 = m.insert_or_assign(std::next(m.begin(), 2), std::move(mvkey8), std::move(mv8));
+ assert(m.size() == 14);
+ assert(mv8.moved()); // was moved from
+ assert(mvkey8.moved()); // was moved from
+ assert(r8->first.get() == 11); // key
+ assert(r8->second.get() == 13); // value
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
new file mode 100644
index 00000000000000..162ec57cd44ee9
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
@@ -0,0 +1,250 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+#include "../helpers.h"
+
+// template<class K, class M>
+// pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
+// template<class K, class M>
+// iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+
+// Constraints:
+// The qualified-id Compare::is_transparent is valid and denotes a type.
+// is_constructible_v<key_type, K> is true.
+// is_assignable_v<mapped_type&, M> is true.
+// is_constructible_v<mapped_type, M> is true.
+
+template <class Map, class K, class M>
+concept CanInsertOrAssign =
+ requires(Map map, K&& k, M&& m) { map.insert_or_assign(std::forward<K>(k), std::forward<M>(m)); };
+
+template <class Map, class K, class M>
+concept CanInsertOrAssignIter = requires(Map map, typename Map::const_iterator iter, K&& k, M&& m) {
+ map.insert_or_assign(iter, std::forward<K>(k), std::forward<M>(m));
+};
+
+template <class From>
+struct ConstructAndAssignFrom {
+ explicit ConstructAndAssignFrom(From);
+ ConstructAndAssignFrom& operator=(From);
+};
+
+template <class From>
+struct ConstructFrom {
+ explicit ConstructFrom(From);
+};
+
+template <class From>
+struct AssignFrom {
+ AssignFrom& operator=(From);
+};
+
+struct Value {};
+
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ NonConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, NonTransparentComparator>,
+ NonConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ int>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ NonConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, NonTransparentComparator>,
+ NonConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ int>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>, TransparentComparator>,
+ ConvertibleTransparent<int>,
+ Value>);
+
+int main(int, char**) {
+ { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+ using M = std::flat_map<int, Moveable, TransparentComparator>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+
+ for (int i = 0; i < 20; i += 2) {
+ Moveable mv(i + 1, i + 1);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(ConvertibleTransparent<int>{i}, std::move(mv));
+ assert(m.size() == 10);
+ assert(!r1.second); // was not inserted
+ assert(mv.moved()); // was moved from
+ assert(r1.first->first == i); // key
+ assert(r1.first->second.get() == i + 1); // value
+ }
+
+ Moveable mv1(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.insert_or_assign(ConvertibleTransparent<int>{-1}, std::move(mv1));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv1.moved()); // was moved from
+ assert(r2.first->first == -1); // key
+ assert(r2.first->second.get() == 5); // value
+
+ Moveable mv2(9, 9.0);
+ std::same_as<R> decltype(auto) r3 = m.insert_or_assign(ConvertibleTransparent<int>{3}, std::move(mv2));
+ assert(m.size() == 12);
+ assert(r3.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r3.first->first == 3); // key
+ assert(r3.first->second.get() == 9); // value
+
+ Moveable mv3(-1, 5.0);
+ std::same_as<R> decltype(auto) r4 = m.insert_or_assign(ConvertibleTransparent<int>{117}, std::move(mv3));
+ assert(m.size() == 13);
+ assert(r4.second); // was inserted
+ assert(mv3.moved()); // was moved from
+ assert(r4.first->first == 117); // key
+ assert(r4.first->second.get() == -1); // value
+ }
+
+ { // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
+ using M = std::flat_map<int, Moveable, TransparentComparator>;
+ M m;
+ using R = M::iterator;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+ M::const_iterator it = m.find(2);
+
+ Moveable mv1(3, 3.0);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(it, ConvertibleTransparent<int>{2}, std::move(mv1));
+ assert(m.size() == 10);
+ assert(mv1.moved()); // was moved from
+ assert(r1->first == 2); // key
+ assert(r1->second.get() == 3); // value
+
+ Moveable mv2(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.insert_or_assign(it, ConvertibleTransparent<int>{3}, std::move(mv2));
+ assert(m.size() == 11);
+ assert(mv2.moved()); // was moved from
+ assert(r2->first == 3); // key
+ assert(r2->second.get() == 5); // value
+
+ // wrong hint: begin()
+ Moveable mv3(7, 7.0);
+ std::same_as<R> decltype(auto) r3 = m.insert_or_assign(m.begin(), ConvertibleTransparent<int>{4}, std::move(mv3));
+ assert(m.size() == 11);
+ assert(mv3.moved()); // was moved from
+ assert(r3->first == 4); // key
+ assert(r3->second.get() == 7); // value
+
+ Moveable mv4(9, 9.0);
+ std::same_as<R> decltype(auto) r4 = m.insert_or_assign(m.begin(), ConvertibleTransparent<int>{5}, std::move(mv4));
+ assert(m.size() == 12);
+ assert(mv4.moved()); // was moved from
+ assert(r4->first == 5); // key
+ assert(r4->second.get() == 9); // value
+
+ // wrong hint: end()
+ Moveable mv5(11, 11.0);
+ std::same_as<R> decltype(auto) r5 = m.insert_or_assign(m.end(), ConvertibleTransparent<int>{6}, std::move(mv5));
+ assert(m.size() == 12);
+ assert(mv5.moved()); // was moved from
+ assert(r5->first == 6); // key
+ assert(r5->second.get() == 11); // value
+
+ Moveable mv6(13, 13.0);
+ std::same_as<R> decltype(auto) r6 = m.insert_or_assign(m.end(), ConvertibleTransparent<int>{7}, std::move(mv6));
+ assert(m.size() == 13);
+ assert(mv6.moved()); // was moved from
+ assert(r6->first == 7); // key
+ assert(r6->second.get() == 13); // value
+
+ // wrong hint: third element
+ Moveable mv7(15, 15.0);
+ std::same_as<R> decltype(auto) r7 =
+ m.insert_or_assign(std::next(m.begin(), 2), ConvertibleTransparent<int>{8}, std::move(mv7));
+ assert(m.size() == 13);
+ assert(mv7.moved()); // was moved from
+ assert(r7->first == 8); // key
+ assert(r7->second.get() == 15); // value
+
+ Moveable mv8(17, 17.0);
+ std::same_as<R> decltype(auto) r8 =
+ m.insert_or_assign(std::next(m.begin(), 2), ConvertibleTransparent<int>{9}, std::move(mv8));
+ assert(m.size() == 14);
+ assert(mv8.moved()); // was moved from
+ assert(r8->first == 9); // key
+ assert(r8->second.get() == 17); // value
+ }
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto p = m.insert_or_assign(ConvertibleTransparent<int>{3}, 5);
+ assert(!p.second);
+ assert(transparent_used);
+ }
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto it = m.insert_or_assign(m.begin(), ConvertibleTransparent<int>{3}, 5);
+ assert(it->second == 5);
+ assert(transparent_used);
+ }
+
+ {
+ auto insert_or_assign = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.insert_or_assign(ConvertibleTransparent<Key>{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(insert_or_assign);
+ }
+
+ {
+ auto insert_or_assign_iter = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.insert_or_assign(m.begin(), ConvertibleTransparent<Key>{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(insert_or_assign_iter);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
index f299edcc7d65bd..1edddc3ace724d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
@@ -20,6 +20,7 @@
#include <ranges>
#include <vector>
+#include "../helpers.h"
#include "MoveOnly.h"
#include "test_macros.h"
#include "test_iterators.h"
@@ -100,5 +101,9 @@ int main(int, char**) {
std::pair<int, int> expected[] = {{1, 1}, {3, 3}, {4, 4}, {5, 5}};
assert(std::ranges::equal(m, expected));
}
+ {
+ auto insert_func = [](auto& m, const auto& newValues) { m.insert_range(newValues); };
+ test_insert_range_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
index bff3c2ce4945b8..cd141d82e96fc3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
@@ -21,6 +21,7 @@
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
+#include "../helpers.h"
template <class Container, class Pair>
void do_insert_rv_test() {
@@ -105,6 +106,15 @@ int main(int, char**) {
assert(r.first->first == 3);
assert(r.first->second == 3);
}
+ {
+ auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ value_type p(std::piecewise_construct, std::tuple(key_arg), std::tuple(value_arg));
+ m.insert(std::move(p));
+ };
+ test_emplace_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
index 155210c8906547..1ead3d67251920 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
@@ -17,6 +17,7 @@
#include <functional>
#include <deque>
+#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -63,6 +64,15 @@ int main(int, char**) {
assert(*std::next(m.begin(), 3) == V(3, 1));
assert(*std::next(m.begin(), 4) == V(4, 1));
}
+ {
+ auto insert_func = [](auto& m, const auto& newValues) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using value_type = typename FlatMap::value_type;
+ std::initializer_list<value_type> il = {{newValues[0].first, newValues[0].second}};
+ m.insert(std::sorted_unique, il);
+ };
+ test_insert_range_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
index f9dea06d45ad33..ef603817d70743 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
@@ -18,6 +18,7 @@
#include <functional>
#include <deque>
+#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
@@ -86,6 +87,12 @@ int main(int, char**) {
M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
assert(m == expected2);
}
+ {
+ auto insert_func = [](auto& m, const auto& newValues) {
+ m.insert(std::sorted_unique, newValues.begin(), newValues.end());
+ };
+ test_insert_range_exception_guarantee(insert_func);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
index b822ebd3e8004a..0b0e2327c8814e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
@@ -18,26 +18,27 @@
#include <concepts>
#include <flat_map>
#include <functional>
+#include <tuple>
+#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
#include "min_allocator.h"
// Constraints: is_constructible_v<pair<key_type, mapped_type>, P> is true.
-template <class M, class...Args>
-concept CanInsert = requires (M m, Args&&... args) {
- m.insert(std::forward<Args>(args)...);
-};
+template <class M, class... Args>
+concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward<Args>(args)...); };
-using Map = std::flat_map<int, double>;
+using Map = std::flat_map<int, double>;
using Iter = Map::const_iterator;
static_assert(CanInsert<Map, std::pair<short, double>&&>);
static_assert(CanInsert<Map, Iter, std::pair<short, double>&&>);
+static_assert(CanInsert<Map, std::tuple<short, double>&&>);
+static_assert(CanInsert<Map, Iter, std::tuple<short, double>&&>);
static_assert(!CanInsert<Map, int>);
static_assert(!CanInsert<Map, Iter, int>);
-
static int expensive_comparisons = 0;
static int cheap_comparisons = 0;
@@ -131,5 +132,23 @@ int main(int, char**) {
ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), Evil())), M::iterator);
ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), m.end())), void);
}
+ {
+ auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using tuple_type = std::tuple<typename FlatMap::key_type, typename FlatMap::mapped_type>;
+ tuple_type t(key_arg, value_arg);
+ m.insert(t);
+ };
+ test_emplace_exception_guarantee(insert_func);
+ }
+ {
+ auto insert_func_iter = [](auto& m, auto key_arg, auto value_arg) {
+ using FlatMap = std::decay_t<decltype(m)>;
+ using tuple_type = std::tuple<typename FlatMap::key_type, typename FlatMap::mapped_type>;
+ tuple_type t(key_arg, value_arg);
+ m.insert(m.begin(), t);
+ };
+ test_emplace_exception_guarantee(insert_func_iter);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
new file mode 100644
index 00000000000000..97b886c40ae807
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
+
+#include <algorithm>
+#include <concepts>
+#include <flat_map>
+#include <functional>
+
+#include "../helpers.h"
+#include "test_macros.h"
+
+template <class T, class... Args>
+concept CanReplace = requires(T t, Args&&... args) { t.replace(std::forward<Args>(args)...); };
+
+using Map = std::flat_map<int, int>;
+static_assert(CanReplace<Map, std::vector<int>, std::vector<int>>);
+static_assert(!CanReplace<Map, const std::vector<int>&, std::vector<int>>);
+static_assert(!CanReplace<Map, std::vector<int>, const std::vector<int>&>);
+static_assert(!CanReplace<Map, const std::vector<int>&, const std::vector<int>&>);
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, int>;
+ M m = M({1, 2, 3}, {4, 5, 6});
+ std::vector<int> new_keys = {7, 8};
+ std::vector<int> new_values = {9, 10};
+ auto expected_keys = new_keys;
+ auto expected_values = new_values;
+ m.replace(std::move(new_keys), std::move(new_values));
+ assert(m.size() == 2);
+ assert(std::ranges::equal(m.keys(), expected_keys));
+ assert(std::ranges::equal(m.values(), expected_values));
+ }
+ {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ using KeyContainer = std::vector<int>;
+ using ValueContainer = ThrowOnMoveContainer<int>;
+ using M = std::flat_map<int, int, std::ranges::less, KeyContainer, ValueContainer>;
+
+ M m;
+ m.emplace(1, 1);
+ m.emplace(2, 2);
+ try {
+ KeyContainer new_keys{3, 4};
+ ValueContainer new_values{5, 6};
+ m.replace(std::move(new_keys), std::move(new_values));
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we clear the map
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+#endif
+ }
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
new file mode 100644
index 00000000000000..b616ec2bb0b307
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
@@ -0,0 +1,135 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// friend void swap(flat_map& x, flat_map& y) noexcept
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+#include "../helpers.h"
+
+// test noexcept
+
+template <class T>
+concept NoExceptAdlSwap = requires(T t1, T t2) {
+ { swap(t1, t2) } noexcept;
+};
+
+static_assert(NoExceptAdlSwap<std::flat_map<int, int>>);
+static_assert(
+ NoExceptAdlSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+
+int main(int, char**) {
+ using V = std::pair<const int, double>;
+ {
+ using M = std::flat_map<int, double>;
+ {
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>;
+ {
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ }
+
+ {
+ auto swap_func = [](auto& m1, auto& m2) { swap(m1, m2); };
+ test_swap_exception_guarantee(swap_func);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
new file mode 100644
index 00000000000000..b6eedff3696fa2
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
@@ -0,0 +1,135 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// void swap(flat_map& y) noexcept;
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+
+#include "MoveOnly.h"
+#include "min_allocator.h"
+#include "test_macros.h"
+#include "../helpers.h"
+
+// test noexcept
+
+template <class T>
+concept NoExceptMemberSwap = requires(T t1, T t2) {
+ { t1.swap(t2) } noexcept;
+};
+
+static_assert(NoExceptMemberSwap<std::flat_map<int, int>>);
+static_assert(
+ NoExceptMemberSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+
+int main(int, char**) {
+ using V = std::pair<const int, double>;
+ {
+ using M = std::flat_map<int, double>;
+ {
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ }
+ {
+ using M =
+ std::flat_map<int,
+ double,
+ std::less<int>,
+ std::vector<int, min_allocator<int>>,
+ std::vector<double, min_allocator<double>>>;
+ {
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ }
+
+ {
+ auto swap_func = [](auto& m1, auto& m2) { m1.swap(m2); };
+ test_swap_exception_guarantee(swap_func);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
new file mode 100644
index 00000000000000..90305e3e03c280
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
@@ -0,0 +1,225 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class... Args>
+// pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
+// template<class... Args>
+// pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+// template<class... Args>
+// iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
+// template<class... Args>
+// iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "../helpers.h"
+#include "min_allocator.h"
+#include "../../../Emplaceable.h"
+
+// Constraints: is_constructible_v<mapped_type, Args...> is true.
+template <class M, class... Args>
+concept CanTryEmplace = requires(M m, Args&&... args) { m.try_emplace(std::forward<Args>(args)...); };
+
+using Map = std::flat_map<Emplaceable, Emplaceable>;
+using Iter = typename Map::const_iterator;
+static_assert(!CanTryEmplace<Map>);
+
+static_assert(CanTryEmplace<Map, const Emplaceable&>);
+static_assert(CanTryEmplace<Map, const Emplaceable&, Emplaceable>);
+static_assert(CanTryEmplace<Map, const Emplaceable&, int, double>);
+static_assert(!CanTryEmplace<Map, const Emplaceable&, const Emplaceable&>);
+static_assert(!CanTryEmplace<Map, const Emplaceable&, int>);
+
+static_assert(CanTryEmplace<Map, Emplaceable>);
+static_assert(CanTryEmplace<Map, Emplaceable, Emplaceable>);
+static_assert(CanTryEmplace<Map, Emplaceable, int, double>);
+static_assert(!CanTryEmplace<Map, Emplaceable, const Emplaceable&>);
+static_assert(!CanTryEmplace<Map, Emplaceable, int>);
+
+static_assert(CanTryEmplace<Map, Iter, const Emplaceable&>);
+static_assert(CanTryEmplace<Map, Iter, const Emplaceable&, Emplaceable>);
+static_assert(CanTryEmplace<Map, Iter, const Emplaceable&, int, double>);
+static_assert(!CanTryEmplace<Map, Iter, const Emplaceable&, const Emplaceable&>);
+static_assert(!CanTryEmplace<Map, Iter, const Emplaceable&, int>);
+
+static_assert(CanTryEmplace<Map, Iter, Emplaceable>);
+static_assert(CanTryEmplace<Map, Iter, Emplaceable, Emplaceable>);
+static_assert(CanTryEmplace<Map, Iter, Emplaceable, int, double>);
+static_assert(!CanTryEmplace<Map, Iter, Emplaceable, const Emplaceable&>);
+static_assert(!CanTryEmplace<Map, Iter, Emplaceable, int>);
+
+int main(int, char**) {
+ { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
+ using M = std::flat_map<int, Moveable>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+
+ assert(m.size() == 10);
+
+ Moveable mv1(3, 3.0);
+ for (int i = 0; i < 20; i += 2) {
+ std::same_as<R> decltype(auto) r = m.try_emplace(i, std::move(mv1));
+ assert(m.size() == 10);
+ assert(!r.second); // was not inserted
+ assert(!mv1.moved()); // was not moved from
+ assert(r.first->first == i); // key
+ }
+
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(-1, std::move(mv1));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv1.moved()); // was moved from
+ assert(r2.first->first == -1); // key
+ assert(r2.first->second.get() == 3); // value
+
+ Moveable mv2(5, 3.0);
+ std::same_as<R> decltype(auto) r3 = m.try_emplace(5, std::move(mv2));
+ assert(m.size() == 12);
+ assert(r3.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r3.first->first == 5); // key
+ assert(r3.first->second.get() == 5); // value
+
+ Moveable mv3(-1, 3.0);
+ std::same_as<R> decltype(auto) r4 = m.try_emplace(117, std::move(mv2));
+ assert(m.size() == 13);
+ assert(r4.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r4.first->first == 117); // key
+ assert(r4.first->second.get() == -1); // value
+ }
+
+ { // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+ using M = std::flat_map<Moveable, Moveable>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2) {
+ m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
+ }
+ assert(m.size() == 10);
+
+ Moveable mvkey1(2, 2.0);
+ Moveable mv1(4, 4.0);
+ std::same_as<R> decltype(auto) r1 = m.try_emplace(std::move(mvkey1), std::move(mv1));
+ assert(m.size() == 10);
+ assert(!r1.second); // was not inserted
+ assert(!mv1.moved()); // was not moved from
+ assert(!mvkey1.moved()); // was not moved from
+ assert(r1.first->first == mvkey1); // key
+
+ Moveable mvkey2(3, 3.0);
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(std::move(mvkey2), std::move(mv1));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv1.moved()); // was moved from
+ assert(mvkey2.moved()); // was moved from
+ assert(r2.first->first.get() == 3); // key
+ assert(r2.first->second.get() == 4); // value
+ }
+
+ { // iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
+ using M = std::flat_map<int, Moveable>;
+ using R = typename M::iterator;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.try_emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+ M::const_iterator it = m.find(2);
+
+ Moveable mv1(3, 3.0);
+ for (int i = 0; i < 20; i += 2) {
+ std::same_as<R> decltype(auto) r1 = m.try_emplace(it, i, std::move(mv1));
+ assert(m.size() == 10);
+ assert(!mv1.moved()); // was not moved from
+ assert(r1->first == i); // key
+ assert(r1->second.get() == i); // value
+ }
+
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(it, 3, std::move(mv1));
+ assert(m.size() == 11);
+ assert(mv1.moved()); // was moved from
+ assert(r2->first == 3); // key
+ assert(r2->second.get() == 3); // value
+ }
+
+ { // iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+ using M = std::flat_map<Moveable, Moveable>;
+ using R = typename M::iterator;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
+ assert(m.size() == 10);
+ M::const_iterator it = std::next(m.cbegin());
+
+ Moveable mvkey1(2, 2.0);
+ Moveable mv1(4, 4.0);
+ std::same_as<R> decltype(auto) r1 = m.try_emplace(it, std::move(mvkey1), std::move(mv1));
+ assert(m.size() == 10);
+ assert(!mv1.moved()); // was not moved from
+ assert(!mvkey1.moved()); // was not moved from
+ assert(r1->first == mvkey1); // key
+
+ Moveable mvkey2(3, 3.0);
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(it, std::move(mvkey2), std::move(mv1));
+ assert(m.size() == 11);
+ assert(mv1.moved()); // was moved from
+ assert(mvkey2.moved()); // was moved from
+ assert(r2->first.get() == 3); // key
+ assert(r2->second.get() == 4); // value
+ }
+
+ {
+ auto try_emplace_ck = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ const Key key{key_arg};
+ m.try_emplace(key, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace_ck);
+ }
+
+ {
+ auto try_emplace_rk = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.try_emplace(Key{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace_rk);
+ }
+
+ {
+ auto try_emplace_iter_ck = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ const Key key{key_arg};
+ m.try_emplace(m.begin(), key, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace_iter_ck);
+ }
+
+ {
+ auto try_emplace_iter_rk = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.try_emplace(m.begin(), Key{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace_iter_rk);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
new file mode 100644
index 00000000000000..66c3b2013210bf
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// template<class K, class... Args>
+// pair<iterator, bool> try_emplace(K&& k, Args&&... args);
+// template<class K, class... Args>
+// iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
+
+#include <flat_map>
+#include <cassert>
+#include <functional>
+#include <deque>
+
+#include "test_macros.h"
+#include "../helpers.h"
+#include "min_allocator.h"
+#include "../../../Emplaceable.h"
+
+// Constraints:
+// The qualified-id Compare::is_transparent is valid and denotes a type.
+// is_constructible_v<key_type, K> is true.
+// is_constructible_v<mapped_type, Args...> is true.
+// For the first overload, is_convertible_v<K&&, const_iterator> and is_convertible_v<K&&, iterator> are both false
+template <class M, class... Args>
+concept CanTryEmplace = requires(M m, Args&&... args) { m.try_emplace(std::forward<Args>(args)...); };
+
+using TransparentMap = std::flat_map<int, Emplaceable, TransparentComparator>;
+using NonTransparentMap = std::flat_map<int, Emplaceable, NonTransparentComparator>;
+
+using TransparentMapIter = typename TransparentMap::iterator;
+using TransparentMapConstIter = typename TransparentMap::const_iterator;
+
+static_assert(!CanTryEmplace<TransparentMap>);
+static_assert(!CanTryEmplace<NonTransparentMap>);
+
+static_assert(CanTryEmplace<TransparentMap, ConvertibleTransparent<int>>);
+static_assert(CanTryEmplace<TransparentMap, ConvertibleTransparent<int>, Emplaceable>);
+static_assert(CanTryEmplace<TransparentMap, ConvertibleTransparent<int>, int, double>);
+static_assert(!CanTryEmplace<TransparentMap, ConvertibleTransparent<int>, const Emplaceable&>);
+static_assert(!CanTryEmplace<TransparentMap, ConvertibleTransparent<int>, int>);
+static_assert(!CanTryEmplace<TransparentMap, NonConvertibleTransparent<int>, Emplaceable>);
+static_assert(!CanTryEmplace<NonTransparentMap, NonConvertibleTransparent<int>, Emplaceable>);
+static_assert(!CanTryEmplace<TransparentMap, ConvertibleTransparent<int>, int>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapIter, Emplaceable>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, Emplaceable>);
+
+static_assert(CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>>);
+static_assert(CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, Emplaceable>);
+static_assert(CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, int, double>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, const Emplaceable&>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, int>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, NonConvertibleTransparent<int>, Emplaceable>);
+static_assert(!CanTryEmplace<NonTransparentMap, TransparentMapConstIter, NonConvertibleTransparent<int>, Emplaceable>);
+static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, int>);
+
+int main(int, char**) {
+ { // pair<iterator, bool> try_emplace(K&& k, Args&&... args);
+ using M = std::flat_map<int, Moveable, TransparentComparator>;
+ using R = std::pair<M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(i, Moveable(i, (double)i));
+
+ assert(m.size() == 10);
+
+ Moveable mv1(3, 3.0);
+ for (int i = 0; i < 20; i += 2) {
+ std::same_as<R> decltype(auto) r = m.try_emplace(ConvertibleTransparent<int>{i}, std::move(mv1));
+ assert(m.size() == 10);
+ assert(!r.second); // was not inserted
+ assert(!mv1.moved()); // was not moved from
+ assert(r.first->first == i); // key
+ }
+
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(ConvertibleTransparent<int>{-1}, std::move(mv1));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv1.moved()); // was moved from
+ assert(r2.first->first == -1); // key
+ assert(r2.first->second.get() == 3); // value
+
+ Moveable mv2(5, 3.0);
+ std::same_as<R> decltype(auto) r3 = m.try_emplace(ConvertibleTransparent<int>{5}, std::move(mv2));
+ assert(m.size() == 12);
+ assert(r3.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r3.first->first == 5); // key
+ assert(r3.first->second.get() == 5); // value
+
+ Moveable mv3(-1, 3.0);
+ std::same_as<R> decltype(auto) r4 = m.try_emplace(ConvertibleTransparent<int>{117}, std::move(mv2));
+ assert(m.size() == 13);
+ assert(r4.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(r4.first->first == 117); // key
+ assert(r4.first->second.get() == -1); // value
+ }
+
+ { // iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
+ using M = std::flat_map<int, Moveable, TransparentComparator>;
+ using R = typename M::iterator;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.try_emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+ M::const_iterator it = m.find(2);
+
+ Moveable mv1(3, 3.0);
+ for (int i = 0; i < 20; i += 2) {
+ std::same_as<R> decltype(auto) r1 = m.try_emplace(it, ConvertibleTransparent<int>{i}, std::move(mv1));
+ assert(m.size() == 10);
+ assert(!mv1.moved()); // was not moved from
+ assert(r1->first == i); // key
+ assert(r1->second.get() == i); // value
+ }
+
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(it, ConvertibleTransparent<int>{3}, std::move(mv1));
+ assert(m.size() == 11);
+ assert(mv1.moved()); // was moved from
+ assert(r2->first == 3); // key
+ assert(r2->second.get() == 3); // value
+ }
+
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto p = m.try_emplace(ConvertibleTransparent<int>{3}, 3);
+ assert(!p.second);
+ assert(transparent_used);
+ }
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto p = m.try_emplace(m.begin(), ConvertibleTransparent<int>{3}, 3);
+ assert(p->second == 3);
+ assert(transparent_used);
+ }
+ {
+ auto try_emplace = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.try_emplace(ConvertibleTransparent<Key>{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace);
+ }
+
+ {
+ auto try_emplace_iter = [](auto& m, auto key_arg, auto value_arg) {
+ using M = std::decay_t<decltype(m)>;
+ using Key = typename M::key_type;
+ m.try_emplace(m.begin(), ConvertibleTransparent<Key>{key_arg}, value_arg);
+ };
+ test_emplace_exception_guarantee(try_emplace_iter);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
new file mode 100644
index 00000000000000..f5a4da1dfd639b
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// const key_container_type& keys() const noexcept
+// const mapped_container_type& values() const noexcept
+
+#include <algorithm>
+#include <cassert>
+#include <flat_map>
+#include <functional>
+#include <utility>
+#include <vector>
+#include <deque>
+#include <string>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+
+int main(int, char**) {
+ {
+ using M = std::flat_map<int, char>;
+ const M m = {{4, 'a'}, {2, 'b'}, {3, 'c'}};
+ std::same_as<const std::vector<int>&> decltype(auto) keys = m.keys();
+ std::same_as<const std::vector<char>&> decltype(auto) values = m.values();
+
+ // noexcept
+ static_assert(noexcept(m.keys()));
+ static_assert(noexcept(m.values()));
+
+ auto expected_keys = {2, 3, 4};
+ auto expected_values = {'b', 'c', 'a'};
+ assert(std::ranges::equal(keys, expected_keys));
+ assert(std::ranges::equal(values, expected_values));
+ }
+
+ {
+ using KeyContainer = std::deque<double>;
+ using ValueContainer = std::vector<int, test_allocator<int>>;
+ using M = std::flat_map<double, int, std::less<>, KeyContainer, ValueContainer>;
+ const M m = {{1.0, 1}, {4.0, 4}, {2.0, 2}};
+ std::same_as<const KeyContainer&> decltype(auto) keys = m.keys();
+ std::same_as<const ValueContainer&> decltype(auto) values = m.values();
+
+ // noexcept
+ static_assert(noexcept(m.keys()));
+ static_assert(noexcept(m.values()));
+
+ auto expected_keys = {1.0, 2.0, 4.0};
+ auto expected_values = {1, 2, 4};
+ assert(std::ranges::equal(keys, expected_keys));
+ assert(std::ranges::equal(values, expected_values));
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
index f8ab721d23440d..c4fd8643a66d3e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
@@ -45,6 +45,15 @@ int main(int, char**) {
assert(m.contains(Transparent<std::string>{""}) == false);
assert(m.contains(Transparent<std::string>{"g"}) == false);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto b = m.contains(Transparent<int>{3});
+ assert(b);
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
index 47d8b90d3dd6a1..b7f7aa0290fac6 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
@@ -45,6 +45,15 @@ int main(int, char**) {
assert(m.count(Transparent<std::string>{""}) == 0);
assert(m.count(Transparent<std::string>{"g"}) == 0);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto n = m.count(Transparent<int>{3});
+ assert(n == 1);
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
index 13de8d34545852..4abbefa9dd10d4 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
@@ -73,6 +73,15 @@ int main(int, char**) {
test_not_found(cm, "aaa", 0);
test_not_found(cm, "zzz", 5);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto p = m.equal_range(Transparent<int>{3});
+ assert(p.first != p.second);
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
index 064b5013b51497..49b5e0a9ef16ed 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
@@ -61,6 +61,15 @@ int main(int, char**) {
test_find(cm, "aaa", 5);
test_find(cm, "zzz", 5);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto it = m.find(Transparent<int>{3});
+ assert(it != m.end());
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
index 90befb129b3a84..b6dc4332c0f130 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
@@ -68,6 +68,15 @@ int main(int, char**) {
test_lower_bound(cm, "golf", 5);
test_lower_bound(cm, "zzz", 5);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto it = m.lower_bound(Transparent<int>{3});
+ assert(it != m.end());
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
index b57e101e35eb3c..a07f13fcdd32a9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
@@ -68,6 +68,15 @@ int main(int, char**) {
test_upper_bound(cm, "golf", 5);
test_upper_bound(cm, "zzz", 5);
}
+ {
+ bool transparent_used = false;
+ TransparentComparator c(transparent_used);
+ std::flat_map<int, int, TransparentComparator> m(std::sorted_unique, {{1, 1}, {2, 2}, {3, 3}}, c);
+ assert(!transparent_used);
+ auto it = m.upper_bound(Transparent<int>{2});
+ assert(it != m.end());
+ assert(transparent_used);
+ }
#if 0
// do we really want to support this weird comparator that gives different answer for Key and Kp?
{
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 236671fd5b3186..c8b884f9e963b7 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -13,7 +13,9 @@
#include <cassert>
#include <string>
#include <vector>
+#include <flat_map>
+#include "test_allocator.h"
#include "test_macros.h"
struct StartsWith {
@@ -67,13 +69,24 @@ using NonConvertibleTransparent = Transparent<T, false>;
struct TransparentComparator {
using is_transparent = void;
+
+ bool* transparent_used = nullptr;
+ TransparentComparator() = default;
+ TransparentComparator(bool& used) : transparent_used(&used) {}
+
template <class T, bool Convertible>
bool operator()(const T& t, const Transparent<T, Convertible>& transparent) const {
+ if (transparent_used != nullptr) {
+ *transparent_used = true;
+ }
return t < transparent.t;
}
template <class T, bool Convertible>
bool operator()(const Transparent<T, Convertible>& transparent, const T& t) const {
+ if (transparent_used != nullptr) {
+ *transparent_used = true;
+ }
return transparent.t < t;
}
@@ -98,52 +111,52 @@ struct NoDefaultCtr {
NoDefaultCtr() = delete;
};
-template <bool Copyable = true>
-struct ThrowOnMove {
- int i;
- ThrowOnMove(int ii) : i(ii) {}
- ThrowOnMove(const ThrowOnMove&)
- requires Copyable
- = default;
-
- ThrowOnMove& operator=(const ThrowOnMove&)
- requires Copyable
- = default;
+template <class T>
+struct EmplaceUnsafeContainer : std::vector<T> {
+ using std::vector<T>::vector;
- ThrowOnMove(ThrowOnMove&&) { throw 42; }
+ template <class... Args>
+ auto emplace(Args&&... args) -> decltype(std::declval<std::vector<T>>().emplace(std::forward<Args>(args)...)) {
+ if (this->size() > 1) {
+ auto it1 = this->begin();
+ auto it2 = it1 + 1;
+ // messing up the container
+ std::iter_swap(it1, it2);
+ }
- ThrowOnMove& operator=(ThrowOnMove&& other) {
- other.i = -1;
throw 42;
}
- friend bool operator==(const ThrowOnMove&, const ThrowOnMove&) = default;
- friend auto operator<=>(const ThrowOnMove&, const ThrowOnMove&) = default;
-};
+ template <class... Args>
+ auto insert(Args&&... args) -> decltype(std::declval<std::vector<T>>().insert(std::forward<Args>(args)...)) {
+ if (this->size() > 1) {
+ auto it1 = this->begin();
+ auto it2 = it1 + 1;
+ // messing up the container
+ std::iter_swap(it1, it2);
+ }
-using CopyableThrowOnMove = ThrowOnMove<true>;
-using MoveOnlyThrowOnMove = ThrowOnMove<false>;
+ throw 42;
+ }
+};
-struct ThrowOnSecondMove {
- int i;
- int count;
- ThrowOnSecondMove(int ii) : i(ii), count(0) {}
- ThrowOnSecondMove(const ThrowOnSecondMove&) = delete;
- ThrowOnSecondMove& operator=(const ThrowOnSecondMove&) = delete;
+template <class T>
+struct ThrowOnEraseContainer : std::vector<T> {
+ using std::vector<T>::vector;
- ThrowOnSecondMove(ThrowOnSecondMove&& other) : i(other.i), count(other.count) {
- if (++count > 1)
- throw 42;
+ template <class... Args>
+ auto erase(Args&&... args) -> decltype(std::declval<std::vector<T>>().erase(std::forward<Args>(args)...)) {
+ throw 42;
}
+};
- ThrowOnSecondMove& operator=(ThrowOnSecondMove&&) {
- if (++count > 1)
- throw 42;
- return *this;
- }
+template <class T>
+struct ThrowOnMoveContainer : std::vector<T> {
+ using std::vector<T>::vector;
- friend bool operator==(const ThrowOnSecondMove&, const ThrowOnSecondMove&) = default;
- friend auto operator<=>(const ThrowOnSecondMove&, const ThrowOnSecondMove&) = default;
+ ThrowOnMoveContainer(ThrowOnMoveContainer&&) { throw 42; }
+
+ ThrowOnMoveContainer& operator=(ThrowOnMoveContainer&&) { throw 42; }
};
template <class T, class Compare = std::less<>>
@@ -152,4 +165,284 @@ bool is_sorted_and_unique(T&& container, Compare compare = Compare()) {
return std::ranges::adjacent_find(container, greater_or_equal_to) == std::ranges::end(container);
}
+template <class F>
+void test_emplace_exception_guarantee(F&& emplace_function) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ using C = TransparentComparator;
+ {
+ // Throw on emplace the key, and underlying has strong exception guarantee
+ using KeyContainer = std::vector<int, test_allocator<int>>;
+ using M = std::flat_map<int, int, C, KeyContainer>;
+
+ LIBCPP_STATIC_ASSERT(std::__container_traits<KeyContainer>::__emplacement_has_strong_exception_safety_guarantee);
+
+ test_allocator_statistics stats;
+
+ KeyContainer a({1, 2, 3, 4}, test_allocator<int>{&stats});
+ std::vector<int> b = {5, 6, 7, 8};
+ [[maybe_unused]] auto expected_keys = a;
+ [[maybe_unused]] auto expected_values = b;
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ stats.throw_after = 1;
+ try {
+ emplace_function(m, 0, 0);
+ assert(false);
+ } catch (const std::bad_alloc&) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is unchanged
+ LIBCPP_ASSERT(m.size() == 4);
+ LIBCPP_ASSERT(m.keys() == expected_keys);
+ LIBCPP_ASSERT(m.values() == expected_values);
+ }
+ }
+ {
+ // Throw on emplace the key, and underlying has no strong exception guarantee
+ using KeyContainer = EmplaceUnsafeContainer<int>;
+ using M = std::flat_map<int, int, C, KeyContainer>;
+
+ LIBCPP_STATIC_ASSERT(!std::__container_traits<KeyContainer>::__emplacement_has_strong_exception_safety_guarantee);
+ KeyContainer a = {1, 2, 3, 4};
+ std::vector<int> b = {5, 6, 7, 8};
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ try {
+ emplace_function(m, 0, 0);
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is cleared
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+ {
+ // Throw on emplace the value, and underlying has strong exception guarantee
+ using ValueContainer = std::vector<int, test_allocator<int>>;
+ ;
+ using M = std::flat_map<int, int, C, std::vector<int>, ValueContainer>;
+
+ LIBCPP_STATIC_ASSERT(std::__container_traits<ValueContainer>::__emplacement_has_strong_exception_safety_guarantee);
+
+ std::vector<int> a = {1, 2, 3, 4};
+ test_allocator_statistics stats;
+ ValueContainer b({1, 2, 3, 4}, test_allocator<int>{&stats});
+
+ [[maybe_unused]] auto expected_keys = a;
+ [[maybe_unused]] auto expected_values = b;
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ stats.throw_after = 1;
+ try {
+ emplace_function(m, 0, 0);
+ assert(false);
+ } catch (const std::bad_alloc&) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the emplaced key is erased and the flat_map is unchanged
+ LIBCPP_ASSERT(m.size() == 4);
+ LIBCPP_ASSERT(m.keys() == expected_keys);
+ LIBCPP_ASSERT(m.values() == expected_values);
+ }
+ }
+ {
+ // Throw on emplace the value, and underlying has no strong exception guarantee
+ using ValueContainer = EmplaceUnsafeContainer<int>;
+ using M = std::flat_map<int, int, C, std::vector<int>, ValueContainer>;
+
+ LIBCPP_STATIC_ASSERT(!std::__container_traits<ValueContainer>::__emplacement_has_strong_exception_safety_guarantee);
+ std::vector<int> a = {1, 2, 3, 4};
+ ValueContainer b = {1, 2, 3, 4};
+
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ try {
+ emplace_function(m, 0, 0);
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, the flat_map is cleared
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+ {
+ // Throw on emplace the value, then throw again on erasing the key
+ using KeyContainer = ThrowOnEraseContainer<int>;
+ using ValueContainer = std::vector<int, test_allocator<int>>;
+ using M = std::flat_map<int, int, C, KeyContainer, ValueContainer>;
+
+ LIBCPP_STATIC_ASSERT(std::__container_traits<ValueContainer>::__emplacement_has_strong_exception_safety_guarantee);
+
+ KeyContainer a = {1, 2, 3, 4};
+ test_allocator_statistics stats;
+ ValueContainer b({1, 2, 3, 4}, test_allocator<int>{&stats});
+
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ stats.throw_after = 1;
+ try {
+ emplace_function(m, 0, 0);
+ assert(false);
+ } catch (const std::bad_alloc&) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we try to erase the key after value emplacement failure.
+ // and after erasure failure, we clear the flat_map
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+#endif
+}
+
+template <class F>
+void test_insert_range_exception_guarantee(F&& insert_function) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ using KeyContainer = EmplaceUnsafeContainer<int>;
+ using ValueContainer = std::vector<int>;
+ using M = std::flat_map<int, int, std::ranges::less, KeyContainer, ValueContainer>;
+ test_allocator_statistics stats;
+ KeyContainer a{1, 2, 3, 4};
+ ValueContainer b{1, 2, 3, 4};
+ M m(std::sorted_unique, std::move(a), std::move(b));
+
+ std::vector<std::pair<int, int>> newValues = {{0, 0}, {1, 1}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
+ stats.throw_after = 1;
+ try {
+ insert_function(m, newValues);
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we clear if anything goes wrong when inserting a range
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+#endif
+}
+
+template <class F>
+void test_erase_exception_guarantee(F&& erase_function) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ {
+ // key erase throws
+ using KeyContainer = ThrowOnEraseContainer<int>;
+ using ValueContainer = std::vector<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ KeyContainer a{1, 2, 3, 4};
+ ValueContainer b{1, 2, 3, 4};
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ try {
+ erase_function(m, 3);
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we clear if anything goes wrong when erasing
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+ {
+ // key erase throws
+ using KeyContainer = std::vector<int>;
+ using ValueContainer = ThrowOnEraseContainer<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ KeyContainer a{1, 2, 3, 4};
+ ValueContainer b{1, 2, 3, 4};
+ M m(std::sorted_unique, std::move(a), std::move(b));
+ try {
+ erase_function(m, 3);
+ assert(false);
+ } catch (int) {
+ assert(m.keys().size() == m.values().size());
+ assert(is_sorted_and_unique(m.keys()));
+ // In libc++, we clear if anything goes wrong when erasing
+ LIBCPP_ASSERT(m.size() == 0);
+ }
+ }
+#endif
+}
+
+template <class F>
+void test_swap_exception_guarantee(F&& swap_function) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+ {
+ // key swap throws
+ using KeyContainer = ThrowOnMoveContainer<int>;
+ using ValueContainer = std::vector<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m1, m2;
+ m1.emplace(1, 1);
+ m1.emplace(2, 2);
+ m2.emplace(3, 3);
+ m2.emplace(4, 4);
+
+ // swap is noexcept
+ swap_function(m1, m2);
+
+ assert(m1.keys().size() == m1.values().size());
+ assert(is_sorted_and_unique(m1.keys()));
+ assert(m2.keys().size() == m2.values().size());
+ assert(is_sorted_and_unique(m2.keys()));
+ // In libc++, we clear if anything goes wrong when erasing
+ LIBCPP_ASSERT(m1.size() == 0);
+ LIBCPP_ASSERT(m2.size() == 0);
+ }
+
+ {
+ // value swap throws
+ using KeyContainer = std::vector<int>;
+ using ValueContainer = ThrowOnMoveContainer<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m1, m2;
+ m1.emplace(1, 1);
+ m1.emplace(2, 2);
+ m2.emplace(3, 3);
+ m2.emplace(4, 4);
+
+ // swap is noexcept
+ swap_function(m1, m2);
+
+ assert(m1.keys().size() == m1.values().size());
+ assert(is_sorted_and_unique(m1.keys()));
+ assert(m2.keys().size() == m2.values().size());
+ assert(is_sorted_and_unique(m2.keys()));
+ // In libc++, we clear if anything goes wrong when erasing
+ LIBCPP_ASSERT(m1.size() == 0);
+ LIBCPP_ASSERT(m2.size() == 0);
+ }
+
+#endif
+}
+
+class Moveable {
+ int int_;
+ double double_;
+
+public:
+ Moveable() : int_(0), double_(0) {}
+ Moveable(int i, double d) : int_(i), double_(d) {}
+ Moveable(Moveable&& x) : int_(x.int_), double_(x.double_) {
+ x.int_ = -1;
+ x.double_ = -1;
+ }
+ Moveable& operator=(Moveable&& x) {
+ int_ = x.int_;
+ x.int_ = -1;
+ double_ = x.double_;
+ x.double_ = -1;
+ return *this;
+ }
+
+ Moveable(const Moveable&) = delete;
+ Moveable& operator=(const Moveable&) = delete;
+ bool operator==(const Moveable& x) const { return int_ == x.int_ && double_ == x.double_; }
+ bool operator<(const Moveable& x) const { return int_ < x.int_ || (int_ == x.int_ && double_ < x.double_); }
+
+ int get() const { return int_; }
+ bool moved() const { return int_ == -1; }
+};
+
#endif // SUPPORT_FLAT_MAP_HELPERS_H
>From d177ec60a8483b98a6488f89e130798a6ad7945f Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 29 Sep 2024 11:42:05 +0100
Subject: [PATCH 21/40] address comment
---
libcxx/include/__flat_map/flat_map.h | 20 +---
libcxx/include/flat_map | 1 +
.../flat.map/assert.input_range.pass.cpp | 5 +-
.../flat.map/assert.sorted_unique.pass.cpp | 7 +-
.../container.adaptors/NaiveStaticVector.h | 32 ++---
.../flat.map.syn/sorted_unique.pass.cpp | 48 ++++++++
.../flat.map/flat.map.capacity/empty.pass.cpp | 16 +--
.../flat.map.capacity/max_size.pass.cpp | 8 +-
.../flat.map/flat.map.capacity/size.pass.cpp | 29 ++++-
.../flat.map/flat.map.cons/alloc.pass.cpp | 2 +-
.../flat.map/flat.map.cons/deduct.pass.cpp | 109 ------------------
.../flat.map.cons/move_exceptions.pass.cpp | 1 -
.../flat.map.cons/move_noexcept.pass.cpp | 13 ---
.../flat.map.cons/sorted_container.pass.cpp | 19 +--
.../flat.map.erasure/erase_if.pass.cpp | 13 ---
.../flat.map.iterators/iterator.pass.cpp | 27 -----
...rator_concept_conformance.compile.pass.cpp | 42 -------
...range_concept_conformance.compile.pass.cpp | 26 -----
.../container.adaptors/flat.map/helpers.h | 22 +---
.../flat.map/incomplete_type.pass.cpp | 2 -
libcxx/test/support/MinSequenceContainer.h | 34 +++---
21 files changed, 136 insertions(+), 340 deletions(-)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 73d2c457ef1f58..12d6240ac8c06a 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -789,20 +789,12 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- try {
-# endif
- ranges::swap(__compare_, __y.__compare_);
- ranges::swap(__containers_.keys, __y.__containers_.keys);
- ranges::swap(__containers_.values, __y.__containers_.values);
-# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
- } catch (...) {
- // todo: how can we tell the user that the swap is unsuccessful?
- // need to swallow the exception because the function is noexcept
- clear() /* noexcept */;
- __y.clear() /*noexcept*/;
- }
-# endif
+ // warning: The spec has unconditional noexcept, which means that
+ // if any of the following functions throw an exception,
+ // std::terminate will be called
+ ranges::swap(__compare_, __y.__compare_);
+ ranges::swap(__containers_.keys, __y.__containers_.keys);
+ ranges::swap(__containers_.values, __y.__containers_.values);
}
_LIBCPP_HIDE_FROM_ABI void clear() noexcept {
diff --git a/libcxx/include/flat_map b/libcxx/include/flat_map
index 29a2dc4ed95421..5f88119b5b1089 100644
--- a/libcxx/include/flat_map
+++ b/libcxx/include/flat_map
@@ -6,6 +6,7 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
+
#ifndef _LIBCPP_FLAT_MAP
#define _LIBCPP_FLAT_MAP
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
index 7f4131dc317a9c..2db803b53441f1 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp
@@ -4,6 +4,7 @@
// 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
@@ -18,7 +19,9 @@
//
#include <flat_map>
-#include <cassert>
+#include <functional>
+#include <memory>
+#include <vector>
#include "check_assertion.h"
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
index 0f4038bac35f80..dcd6314a5c00e4 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
@@ -4,6 +4,7 @@
// 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
@@ -18,7 +19,11 @@
//
#include <flat_map>
-#include <cassert>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <utility>
+#include <vector>
#include "check_assertion.h"
diff --git a/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h b/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
index 1f5d24c0e4eab7..61fa3504e34e3a 100644
--- a/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
+++ b/libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h
@@ -9,31 +9,37 @@
#ifndef SUPPORT_NAIVE_STATIC_VECTOR_H
#define SUPPORT_NAIVE_STATIC_VECTOR_H
+#include <cstddef>
+#include <utility>
#include "test_iterators.h"
#include "test_macros.h"
-template<class T, size_t N>
+template <class T, std::size_t N>
struct NaiveStaticVector {
struct CapacityError {};
- using value_type = T;
+ using value_type = T;
using difference_type = short;
- using size_type = unsigned short;
- using iterator = random_access_iterator<T*>;
- using const_iterator = random_access_iterator<const T*>;
+ using size_type = unsigned short;
+ using iterator = random_access_iterator<T*>;
+ using const_iterator = random_access_iterator<const T*>;
explicit NaiveStaticVector() = default;
- template<class It> explicit NaiveStaticVector(It first, It last) { while (first != last) insert(*first++); }
+ template <class It>
+ explicit NaiveStaticVector(It first, It last) {
+ while (first != last)
+ insert(*first++);
+ }
// Moving-from a NaiveStaticVector leaves the source vector holding moved-from objects.
// This is intentional (the "Naive" in the name).
// Specifically, moving-out-of a sorted+uniqued NaiveStaticVector<MoveOnly>
// will leave it in a non-sorted+uniqued state.
- NaiveStaticVector(const NaiveStaticVector&) = default;
- NaiveStaticVector(NaiveStaticVector&&) = default; // deliberately don't reset size_
+ NaiveStaticVector(const NaiveStaticVector&) = default;
+ NaiveStaticVector(NaiveStaticVector&&) = default; // deliberately don't reset size_
NaiveStaticVector& operator=(const NaiveStaticVector&) = default;
- NaiveStaticVector& operator=(NaiveStaticVector&&) = default;
+ NaiveStaticVector& operator=(NaiveStaticVector&&) = default;
iterator begin() { return iterator(data_); }
const_iterator begin() const { return const_iterator(data_); }
@@ -45,7 +51,7 @@ struct NaiveStaticVector {
void clear() { size_ = 0; }
- template<class It>
+ template <class It>
iterator insert(const_iterator pos, It first, It last) {
iterator result = pos - cbegin() + begin();
while (first != last) {
@@ -78,13 +84,11 @@ struct NaiveStaticVector {
return begin() + i;
}
- iterator erase(const_iterator pos) {
- return erase(pos, std::next(pos));
- }
+ iterator erase(const_iterator pos) { return erase(pos, std::next(pos)); }
private:
T data_[N];
- size_t size_ = 0;
+ std::size_t size_ = 0;
};
#endif // SUPPORT_NAIVE_STATIC_VECTOR_H
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
new file mode 100644
index 00000000000000..59338e2da5aedc
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <flat_map>
+
+// struct sorted_unique_t { explicit sorted_unique_t() = default; };
+// inline constexpr sorted_unique_t sorted_unique{};
+
+#include <cassert>
+#include <concepts>
+#include <flat_map>
+#include <type_traits>
+
+template <class T>
+void implicit_test(T) {}
+
+template <class T>
+concept HasImplicitDefaultCtor = requires { implicit_test<T>({}); };
+
+static_assert(std::is_default_constructible_v<std::sorted_unique_t>);
+static_assert(std::is_trivially_default_constructible_v<std::sorted_unique_t>);
+static_assert(!HasImplicitDefaultCtor<std::sorted_unique_t>);
+
+constexpr bool test() {
+ {
+ [[maybe_unused]] std::sorted_unique_t s;
+ }
+ {
+ [[maybe_unused]] std::same_as<const std::sorted_unique_t&> decltype(auto) s = (std::sorted_unique);
+ }
+ {
+ [[maybe_unused]] std::same_as<const std::sorted_unique_t> decltype(auto) copy = std::sorted_unique;
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
index 762b5596b75741..75f1af7ca16d4d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
@@ -46,20 +46,6 @@ int main(int, char**) {
m.clear();
assert(m.empty());
}
-#if 0
- // vector<bool> is not supported
- {
- typedef std::flat_map<bool, bool> M;
- M m;
- ASSERT_SAME_TYPE(decltype(m.empty()), bool);
- ASSERT_NOEXCEPT(m.empty());
- assert(m.empty());
- assert(std::as_const(m).empty());
- m = {{false, false}};
- assert(!m.empty());
- m.clear();
- assert(m.empty());
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
index 3f464c65d43a84..b274b2d2704e32 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
@@ -29,7 +29,7 @@ int main(int, char**) {
using C = std::flat_map<int, int, std::less<int>, std::vector<int, A1>, std::vector<int, A2>>;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
- C c;
+ const C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
assert(c.max_size() <= 10);
@@ -41,7 +41,7 @@ int main(int, char**) {
using C = std::flat_map<int, int, std::less<int>, std::vector<int, A2>, std::vector<int, A1>>;
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
- C c;
+ const C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
assert(c.max_size() <= 10);
@@ -53,7 +53,7 @@ int main(int, char**) {
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
- C c;
+ const C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
assert(c.max_size() <= max_dist);
@@ -64,7 +64,7 @@ int main(int, char**) {
ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(C::size_type, std::size_t);
const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
- C c;
+ const C c;
ASSERT_NOEXCEPT(c.max_size());
ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
assert(c.max_size() <= max_dist);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
index 95c7dbd24f27c0..a3447026792ed2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
@@ -20,12 +20,37 @@
int main(int, char**) {
{
- using M = std::flat_map<int, char>;
- M m = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
+ using M = std::flat_map<int, char>;
+ const M m = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
ASSERT_NOEXCEPT(m.size());
assert(m.size() == 3);
}
+ {
+ using M = std::flat_map<int, char>;
+ const M m = {{1, 'a'}};
+ ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+ ASSERT_NOEXCEPT(m.size());
+ assert(m.size() == 1);
+ }
+ {
+ using M = std::flat_map<int, char>;
+ const M m;
+ ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+ ASSERT_NOEXCEPT(m.size());
+ assert(m.size() == 0);
+ }
+ {
+ using M = std::flat_map<int, char>;
+ M m;
+ std::size_t s = 1000000;
+ for (auto i = 0u; i < s; ++i) {
+ m.emplace(i, 'a');
+ }
+ ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+ ASSERT_NOEXCEPT(m.size());
+ assert(m.size() == s);
+ }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
index 803adf3a2a092e..53ccb388084c22 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -44,7 +44,7 @@ int main(int, char**) {
static_assert(!std::is_constructible_v<M3, const A2&>);
}
{
- //explicit
+ // explicit
using M =
std::flat_map<int,
long,
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
index e1f458e1e5977d..4013c706354826 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -212,41 +212,6 @@ void test_iter_iter() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
assert(std::ranges::equal(m, sorted_arr));
}
-#if 0
-// spec has no CTAD for (Iter, Iter, Allocator) or (sorted_unique_t, Iter, Iter, Allocator)
- {
- std::flat_map m(std::begin(arr), std::end(arr), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::begin(arrc), std::end(arrc), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
-#endif
{
std::flat_map<int, short> mo;
std::flat_map m(mo.begin(), mo.end());
@@ -289,41 +254,6 @@ void test_iter_iter_compare() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
assert(std::ranges::equal(m, sorted_arr));
}
-#if 0
-// spec has no CTAD for (Iter, Iter, Compare, Allocator) or (sorted_unique_t, Iter, Iter, Compare, Allocator)
- {
- std::flat_map m(std::begin(arr), std::end(arr), C(), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::begin(arrc), std::end(arrc), C(), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C(), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
- {
- std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C(), test_allocator<short>(0, 44));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 44);
- assert(m.values().get_allocator().get_id() == 44);
- }
-#endif
{
std::flat_map<int, short> mo;
std::flat_map m(mo.begin(), mo.end(), C());
@@ -350,25 +280,6 @@ void test_initializer_list() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
assert(std::ranges::equal(m, sorted_arr));
}
-#if 0
-// spec has no CTAD for (initializer_list, Allocator) or (sorted_unique_t, initializer_list, Allocator)
- {
- std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, test_allocator<long>(0, 42));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 42);
- assert(m.values().get_allocator().get_id() == 42);
- }
- {
- std::flat_map m(std::sorted_unique, { std::pair{1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} }, test_allocator<long>(0, 42));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, std::less<int>, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 42);
- assert(m.values().get_allocator().get_id() == 42);
- }
-#endif
}
void test_initializer_list_compare() {
@@ -386,25 +297,6 @@ void test_initializer_list_compare() {
ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
assert(std::ranges::equal(m, sorted_arr));
}
-#if 0
-// spec has no CTAD for (initializer_list, Compare, Allocator) or (sorted_unique_t, initializer_list, Compare, Allocator)
- {
- std::flat_map m({ std::pair{1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} }, C(), test_allocator<long>(0, 42));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 42);
- assert(m.values().get_allocator().get_id() == 42);
- }
- {
- std::flat_map m(std::sorted_unique, { std::pair{INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} }, C(), test_allocator<long>(0, 42));
-
- ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C, std::vector<int, test_allocator<int>>, std::vector<long, test_allocator<long>>>);
- assert(std::ranges::equal(m, sorted_arr));
- assert(m.keys().get_allocator().get_id() == 42);
- assert(m.values().get_allocator().get_id() == 42);
- }
-#endif
}
void test_from_range() {
@@ -465,7 +357,6 @@ int main(int, char**) {
test_from_range();
test_from_range_compare();
-
AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
{
std::flat_map s = {std::make_pair(1, 'a')}; // flat_map(initializer_list<pair<int, char>>)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
index f052ba3ca7ed1d..2cf9bdb8cb0cd9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
@@ -22,7 +22,6 @@
#include <vector>
#include "test_macros.h"
-//#include "MinSequenceContainer.h"
static int countdown = 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
index e3a6c944c8d5fd..3f8bb57e6658b1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
@@ -100,18 +100,5 @@ int main(int, char**) {
C c;
C d = std::move(c);
}
- // todo: why?
- /*
- {
- // Moving the flat_map copies the comparator (to support std::function comparators)
- using C = std::flat_map<int, int, MoveSensitiveComp>;
- LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);
- C c;
- assert(!c.key_comp().is_moved_from_);
- C d = std::move(c);
- LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
- assert(!d.key_comp().is_moved_from_);
- }
- */
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index cac6a348caeb55..cb408214a8a951 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -189,29 +189,16 @@ int main(int, char**) {
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
-#if 0
{
using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
std::pmr::monotonic_buffer_resource mr;
std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks({1,2,4,10}, &mr);
- std::pmr::vector<int> vs({4,3,2,1}, &mr);
+ std::pmr::vector<int> ks({1, 2, 4, 10}, &mr);
+ std::pmr::vector<int> vs({4, 3, 2, 1}, &mr);
vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
- assert(ks.empty()); // ks is moved-from (after LWG 3802)
- assert(vs.empty()); // vs is moved-from (after LWG 3802)
- assert((vm[0] == M{{1,4}, {2,3}, {4,2}, {10,1}}));
+ assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
assert(vm[0].keys().get_allocator().resource() == &mr);
assert(vm[0].values().get_allocator().resource() == &mr);
}
- {
- using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
- std::pmr::vector<M> vm;
- std::pmr::vector<MoveOnly> ks;
- std::pmr::vector<MoveOnly> vs;
- vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs)); // this was a hard error before LWG 3802
- assert(vm.size() == 1);
- assert(vm[0].empty());
- }
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
index c6eda7f042639b..fb0563eec5376b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp
@@ -89,18 +89,5 @@ int main(int, char**) {
test<std::flat_map<long, int>>();
test<std::flat_map<double, int>>();
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- std::flat_map<bool, bool> fs = {{true, false}, {false, true}};
- std::same_as<size_t> auto n = std::erase_if(fs, [](M::const_reference x) { return x.first; });
- assert((fs == M{{false, true}}));
- assert(n == 1);
- n = std::erase_if(fs, [](const M::value_type& x) { return !x.first; });
- assert(fs.empty());
- assert(n == 1);
- }
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
index 531e018c0cebba..48a994f877bdb3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
@@ -64,33 +64,6 @@ int main(int, char**) {
}
assert(i == m.begin());
}
-// std::string is not a sequence container
-#if 0
- {
- using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
- const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
- ASSERT_SAME_TYPE(decltype(m.begin()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(m.end()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(m.cend()), M::const_iterator);
- assert(m.size() == 4);
- assert(std::distance(m.begin(), m.end()) == 4);
- assert(std::distance(m.cbegin(), m.cend()) == 4);
- M::const_iterator i; // default-construct
- i = m.begin(); // move-assignment
- for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
- assert(i->first == j);
- assert(i->second == 'a' + j - 1);
- }
- assert(i == m.end());
- for (int j = 4; j >= 1; --j) {
- --i; // pre-decrement
- assert((*i).first == j);
- assert((*i).second == 'a' + j - 1);
- }
- assert(i == m.begin());
- }
-#endif
{
// N3644 testing
using C = std::flat_map<int, char>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
index 6edccf3370fcd5..0a7e608ae57b16 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -100,46 +100,4 @@ void test() {
static_assert(std::indirectly_movable_storable<RI, std::pair<char*, int>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<char*, int>*>);
}
-#if 0
- // vector<bool> is not supported
- {
- using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
- using CRI = C::const_reverse_iterator;
- static_assert(std::random_access_iterator<I>);
- static_assert(std::random_access_iterator<CI>);
- static_assert(std::random_access_iterator<RI>);
- static_assert(std::random_access_iterator<CRI>);
- static_assert(!std::contiguous_iterator<I>);
- static_assert(!std::contiguous_iterator<CI>);
- static_assert(!std::contiguous_iterator<RI>);
- static_assert(!std::contiguous_iterator<CRI>);
- static_assert(!std::indirectly_writable<I, std::pair<char, bool>>);
- static_assert(!std::indirectly_writable<CI, std::pair<char, bool>>);
- static_assert(!std::indirectly_writable<RI, std::pair<char, bool>>);
- static_assert(!std::indirectly_writable<CRI, std::pair<char, bool>>);
- static_assert(std::sentinel_for<I, I>);
- static_assert(std::sentinel_for<I, CI>);
- static_assert(!std::sentinel_for<I, RI>);
- static_assert(!std::sentinel_for<I, CRI>);
- static_assert(std::sentinel_for<CI, I>);
- static_assert(std::sentinel_for<CI, CI>);
- static_assert(!std::sentinel_for<CI, RI>);
- static_assert(!std::sentinel_for<CI, CRI>);
- static_assert(!std::sentinel_for<RI, I>);
- static_assert(!std::sentinel_for<RI, CI>);
- static_assert(std::sentinel_for<RI, RI>);
- static_assert(std::sentinel_for<RI, CRI>);
- static_assert(!std::sentinel_for<CRI, I>);
- static_assert(!std::sentinel_for<CRI, CI>);
- static_assert(std::sentinel_for<CRI, RI>);
- static_assert(std::sentinel_for<CRI, CRI>);
- static_assert(std::indirectly_movable_storable<I, std::pair<char, bool>*>);
- static_assert(std::indirectly_movable_storable<CI, std::pair<char, bool>*>);
- static_assert(std::indirectly_movable_storable<RI, std::pair<char, bool>*>);
- static_assert(std::indirectly_movable_storable<CRI, std::pair<char, bool>*>);
- }
-#endif
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
index 8a0beaa5ad9db2..ae1434ad6bd87c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
@@ -40,30 +40,4 @@ void test() {
static_assert(!std::ranges::borrowed_range<const C>);
static_assert(!std::ranges::viewable_range<const C>);
}
-#if 0
- // vector<bool> is not supported
- {
- using C = std::flat_map<char, bool, std::less<>, std::string, std::vector<bool>>;
-
- static_assert(std::same_as<std::ranges::iterator_t<C>, C::iterator>);
- static_assert(std::ranges::random_access_range<C>);
- static_assert(!std::ranges::contiguous_range<C>);
- static_assert(std::ranges::common_range<C>);
- static_assert(std::ranges::input_range<C>);
- static_assert(!std::ranges::view<C>);
- static_assert(std::ranges::sized_range<C>);
- static_assert(!std::ranges::borrowed_range<C>);
- static_assert(std::ranges::viewable_range<C>);
-
- static_assert(std::same_as<std::ranges::iterator_t<const C>, C::const_iterator>);
- static_assert(std::ranges::random_access_range<const C>);
- static_assert(!std::ranges::contiguous_range<const C>);
- static_assert(std::ranges::common_range<const C>);
- static_assert(std::ranges::input_range<const C>);
- static_assert(!std::ranges::view<const C>);
- static_assert(std::ranges::sized_range<const C>);
- static_assert(!std::ranges::borrowed_range<const C>);
- static_assert(!std::ranges::viewable_range<const C>);
-
-#endif
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index c8b884f9e963b7..a35426caa0fb02 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -17,6 +17,7 @@
#include "test_allocator.h"
#include "test_macros.h"
+#include "check_assertion.h"
struct StartsWith {
explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {}
@@ -377,17 +378,8 @@ void test_swap_exception_guarantee(F&& swap_function) {
m1.emplace(2, 2);
m2.emplace(3, 3);
m2.emplace(4, 4);
-
// swap is noexcept
- swap_function(m1, m2);
-
- assert(m1.keys().size() == m1.values().size());
- assert(is_sorted_and_unique(m1.keys()));
- assert(m2.keys().size() == m2.values().size());
- assert(is_sorted_and_unique(m2.keys()));
- // In libc++, we clear if anything goes wrong when erasing
- LIBCPP_ASSERT(m1.size() == 0);
- LIBCPP_ASSERT(m2.size() == 0);
+ EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
}
{
@@ -403,15 +395,7 @@ void test_swap_exception_guarantee(F&& swap_function) {
m2.emplace(4, 4);
// swap is noexcept
- swap_function(m1, m2);
-
- assert(m1.keys().size() == m1.values().size());
- assert(is_sorted_and_unique(m1.keys()));
- assert(m2.keys().size() == m2.values().size());
- assert(is_sorted_and_unique(m2.keys()));
- // In libc++, we clear if anything goes wrong when erasing
- LIBCPP_ASSERT(m1.size() == 0);
- LIBCPP_ASSERT(m2.size() == 0);
+ EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
}
#endif
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
index a96d0d8c1a95ba..81c590ba73a157 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp
@@ -15,8 +15,6 @@
#include <flat_map>
-#include "test_macros.h"
-
struct A {
using Map = std::flat_map<A, A>;
int data;
diff --git a/libcxx/test/support/MinSequenceContainer.h b/libcxx/test/support/MinSequenceContainer.h
index 9f6cadbef1a8e5..4d26b301fd4efe 100644
--- a/libcxx/test/support/MinSequenceContainer.h
+++ b/libcxx/test/support/MinSequenceContainer.h
@@ -14,17 +14,17 @@
#include "test_iterators.h"
-template<class T, class Iterator = random_access_iterator<T*>,
- class ConstIterator = random_access_iterator<const T*>>
+template <class T, class Iterator = random_access_iterator<T*>, class ConstIterator = random_access_iterator<const T*>>
struct MinSequenceContainer {
- using value_type = T;
+ using value_type = T;
using difference_type = short;
- using size_type = unsigned short;
- using iterator = Iterator;
- using const_iterator = ConstIterator;
+ using size_type = unsigned short;
+ using iterator = Iterator;
+ using const_iterator = ConstIterator;
explicit MinSequenceContainer() = default;
- template<class It> explicit MinSequenceContainer(It first, It last) : data_(first, last) {}
+ template <class It>
+ explicit MinSequenceContainer(It first, It last) : data_(first, last) {}
MinSequenceContainer(std::initializer_list<T> il) : data_(il) {}
iterator begin() { return iterator(data_.data()); }
const_iterator begin() const { return const_iterator(data_.data()); }
@@ -36,20 +36,14 @@ struct MinSequenceContainer {
void clear() { data_.clear(); }
- template<class It>
+ template <class It>
iterator insert(const_iterator p, It first, It last) {
- auto it = data_.insert(
- p - cbegin() + data_.begin(),
- first, last
- );
+ auto it = data_.insert(p - cbegin() + data_.begin(), first, last);
return it - data_.begin() + begin();
}
iterator insert(const_iterator p, int value) {
- auto it = data_.insert(
- p - cbegin() + data_.begin(),
- value
- );
+ auto it = data_.insert(p - cbegin() + data_.begin(), value);
return it - data_.begin() + begin();
}
@@ -66,16 +60,16 @@ namespace MinSequenceContainer_detail {
// MinSequenceContainer is non-allocator-aware, because flat_set supports
// such (non-STL) container types, and we want to make sure they are supported.
-template<class T>
+template <class T>
concept HasAllocatorType = requires { typename T::allocator_type; };
static_assert(!HasAllocatorType<MinSequenceContainer<int>>);
// MinSequenceContainer by itself doesn't support .emplace(), because we want
// to at least somewhat support (non-STL) container types with nothing but .insert().
-template<class T>
-concept HasEmplace = requires (T& t) { t.emplace(42); };
+template <class T>
+concept HasEmplace = requires(T& t) { t.emplace(42); };
static_assert(!HasEmplace<MinSequenceContainer<int>>);
-} // MinSequenceContainer_detail
+} // namespace MinSequenceContainer_detail
#endif // SUPPORT_MIN_SEQUENCE_CONTAINER_H
>From e6d9d11ee188f900f2d4d84532211b66e7b00dd9 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 5 Oct 2024 12:26:44 +0100
Subject: [PATCH 22/40] parameterise tests
---
.../flat.map/flat.map.access/at.pass.cpp | 69 +---
.../flat.map.access/at_transparent.pass.cpp | 70 +---
.../flat.map.access/index_key.pass.cpp | 75 ++--
.../flat.map.access/index_rv_key.pass.cpp | 34 +-
.../index_transparent.pass.cpp | 49 +--
.../flat.map/flat.map.capacity/empty.pass.cpp | 44 ++-
.../flat.map.capacity/max_size.pass.cpp | 2 +
.../flat.map/flat.map.capacity/size.pass.cpp | 19 +-
.../assign_initializer_list.pass.cpp | 46 +--
.../flat.map.iterators/iterator.pass.cpp | 85 +++--
...rator_concept_conformance.compile.pass.cpp | 127 +++----
...range_concept_conformance.compile.pass.cpp | 18 +-
.../flat.map.modifiers/clear.pass.cpp | 57 ++-
.../flat.map.modifiers/emplace.pass.cpp | 138 +++-----
.../flat.map.modifiers/emplace_hint.pass.cpp | 125 +++----
.../flat.map.modifiers/erase_iter.pass.cpp | 332 ++++++------------
.../erase_iter_iter.pass.cpp | 203 ++++-------
.../flat.map.modifiers/erase_key.pass.cpp | 139 +++-----
.../erase_key_transparent.pass.cpp | 108 +++---
.../flat.map.modifiers/extract.pass.cpp | 36 +-
.../flat.map.modifiers/insert_cv.pass.cpp | 30 +-
.../insert_initializer_list.pass.cpp | 83 ++---
.../insert_iter_cv.pass.cpp | 27 +-
.../insert_iter_iter.pass.cpp | 51 ++-
.../insert_iter_rv.pass.cpp | 61 ++--
.../insert_or_assign.pass.cpp | 90 +++--
.../insert_or_assign_transparent.pass.cpp | 30 +-
.../flat.map.modifiers/insert_range.pass.cpp | 32 +-
.../flat.map.modifiers/insert_rv.pass.cpp | 32 +-
.../insert_sorted_initializer_list.pass.cpp | 72 ++--
.../insert_sorted_iter_iter.pass.cpp | 70 ++--
.../insert_transparent.pass.cpp | 65 ++--
.../flat.map.modifiers/replace.pass.cpp | 37 +-
.../flat.map.modifiers/swap_free.pass.cpp | 142 +++-----
.../flat.map.modifiers/swap_member.pass.cpp | 141 +++-----
.../flat.map.modifiers/try_emplace.pass.cpp | 85 +++--
.../try_emplace_transparent.pass.cpp | 22 +-
.../flat.map.observers/keys_values.pass.cpp | 59 ++--
.../flat.map.operations/contains.pass.cpp | 38 +-
.../contains_transparent.pass.cpp | 57 ++-
.../flat.map.operations/count.pass.cpp | 40 +--
.../count_transparent.pass.cpp | 57 ++-
.../flat.map.operations/equal_range.pass.cpp | 54 ++-
.../equal_range_transparent.pass.cpp | 108 +++---
.../flat.map.operations/find.pass.cpp | 81 ++---
.../find_transparent.pass.cpp | 88 +++--
.../flat.map.operations/lower_bound.pass.cpp | 53 ++-
.../lower_bound_transparent.pass.cpp | 97 +++--
.../flat.map.operations/upper_bound.pass.cpp | 54 ++-
.../upper_bound_transparent.pass.cpp | 96 +++--
libcxx/test/support/MinSequenceContainer.h | 26 +-
51 files changed, 1598 insertions(+), 2156 deletions(-)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
index 57d5a486548625..d30055bf1701cd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp
@@ -14,15 +14,18 @@
// const mapped_type& at(const key_type& k) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <functional>
#include <stdexcept>
#include <vector>
+#include "MinSequenceContainer.h"
#include "min_allocator.h"
#include "test_macros.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
using P = std::pair<int, double>;
P ar[] = {
P(1, 1.5),
@@ -35,7 +38,7 @@ int main(int, char**) {
};
const int one = 1;
{
- std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
assert(m.size() == 7);
assert(m.at(one) == 1.5);
@@ -57,7 +60,8 @@ int main(int, char**) {
assert(m.size() == 7);
}
{
- const std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ const std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(
+ ar, ar + sizeof(ar) / sizeof(ar[0]));
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
assert(m.size() == 7);
assert(m.at(one) == 1.5);
@@ -76,58 +80,13 @@ int main(int, char**) {
assert(m.at(8) == 8.5);
assert(m.size() == 7);
}
- {
- std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>
- m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
- assert(m.size() == 7);
- assert(m.at(one) == 1.5);
- m.at(1) = -1.5;
- assert(m.at(1) == -1.5);
- assert(m.at(2) == 2.5);
- assert(m.at(3) == 3.5);
- assert(m.at(4) == 4.5);
- assert(m.at(5) == 5.5);
-#ifndef TEST_HAS_NO_EXCEPTIONS
- try {
- TEST_IGNORE_NODISCARD m.at(6);
- assert(false);
- } catch (std::out_of_range&) {
- }
-#endif
- assert(m.at(7) == 7.5);
- assert(m.at(8) == 8.5);
- assert(m.size() == 7);
- }
- {
- const std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>
- m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
- assert(m.size() == 7);
- assert(m.at(1) == 1.5);
- assert(m.at(2) == 2.5);
- assert(m.at(3) == 3.5);
- assert(m.at(4) == 4.5);
- assert(m.at(5) == 5.5);
-#ifndef TEST_HAS_NO_EXCEPTIONS
- try {
- TEST_IGNORE_NODISCARD m.at(6);
- assert(false);
- } catch (std::out_of_range&) {
- }
-#endif
- assert(m.at(7) == 7.5);
- assert(m.at(8) == 8.5);
- assert(m.size() == 7);
- }
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
index 2bb6c6d02a048c..13edca915fd005 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp
@@ -14,12 +14,14 @@
// template<class K> const mapped_type& at(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <functional>
#include <stdexcept>
#include "../helpers.h"
#include "min_allocator.h"
+#include "MinSequenceContainer.h"
#include "test_macros.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
@@ -32,7 +34,8 @@ static_assert(CanAt<const TransparentMap>);
static_assert(!CanAt<NonTransparentMap>);
static_assert(!CanAt<const NonTransparentMap>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
using P = std::pair<int, double>;
P ar[] = {
P(1, 1.5),
@@ -45,54 +48,8 @@ int main(int, char**) {
};
const Transparent<int> one{1};
{
- std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
- assert(m.size() == 7);
- assert(m.at(one) == 1.5);
- m.at(one) = -1.5;
- assert(m.at(Transparent<int>{1}) == -1.5);
- assert(m.at(Transparent<int>{2}) == 2.5);
- assert(m.at(Transparent<int>{3}) == 3.5);
- assert(m.at(Transparent<int>{4}) == 4.5);
- assert(m.at(Transparent<int>{5}) == 5.5);
-#ifndef TEST_HAS_NO_EXCEPTIONS
- try {
- TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
- assert(false);
- } catch (std::out_of_range&) {
- }
-#endif
- assert(m.at(Transparent<int>{7}) == 7.5);
- assert(m.at(Transparent<int>{8}) == 8.5);
- assert(m.size() == 7);
- }
- {
- const std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
- assert(m.size() == 7);
- assert(m.at(Transparent<int>{1}) == 1.5);
- assert(m.at(Transparent<int>{2}) == 2.5);
- assert(m.at(Transparent<int>{3}) == 3.5);
- assert(m.at(Transparent<int>{4}) == 4.5);
- assert(m.at(Transparent<int>{5}) == 5.5);
-#ifndef TEST_HAS_NO_EXCEPTIONS
- try {
- TEST_IGNORE_NODISCARD m.at(Transparent<int>{6});
- assert(false);
- } catch (std::out_of_range&) {
- }
-#endif
- assert(m.at(Transparent<int>{7}) == 7.5);
- assert(m.at(Transparent<int>{8}) == 8.5);
- assert(m.size() == 7);
- }
- {
- std::flat_map<int,
- double,
- TransparentComparator,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>
- m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ std::flat_map<int, double, TransparentComparator, KeyContainer, ValueContainer> m(
+ ar, ar + sizeof(ar) / sizeof(ar[0]));
ASSERT_SAME_TYPE(decltype(m.at(one)), double&);
assert(m.size() == 7);
assert(m.at(one) == 1.5);
@@ -114,12 +71,8 @@ int main(int, char**) {
assert(m.size() == 7);
}
{
- const std::flat_map<int,
- double,
- TransparentComparator,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>
- m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ const std::flat_map<int, double, TransparentComparator, KeyContainer, ValueContainer> m(
+ ar, ar + sizeof(ar) / sizeof(ar[0]));
ASSERT_SAME_TYPE(decltype(m.at(one)), const double&);
assert(m.size() == 7);
assert(m.at(Transparent<int>{1}) == 1.5);
@@ -138,6 +91,13 @@ int main(int, char**) {
assert(m.at(Transparent<int>{8}) == 8.5);
assert(m.size() == 7);
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
index 245c87e32227f5..ea2f5d800878a2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp
@@ -13,9 +13,12 @@
// mapped_type& operator[](const key_type& k);
#include <cassert>
+#include <deque>
#include <flat_map>
#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -27,7 +30,8 @@ concept CanIndex = requires(M m, Input k) { m[k]; };
static_assert(CanIndex<std::flat_map<int, double>, const int&>);
static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, const int&>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
using P = std::pair<int, double>;
P ar[] = {
P(1, 1.5),
@@ -39,57 +43,26 @@ int main(int, char**) {
P(8, 8.5),
};
const int one = 1;
- {
- std::flat_map<int, double> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m[one]), double&);
- assert(m.size() == 7);
- assert(m[one] == 1.5);
- assert(m.size() == 7);
- m[1] = -1.5;
- assert(m[1] == -1.5);
- assert(m.size() == 7);
- assert(m[6] == 0);
- assert(m.size() == 8);
- m[6] = 6.5;
- assert(m[6] == 6.5);
- assert(m.size() == 8);
- }
- {
- // allocator
- using A1 = min_allocator<int>;
- using A2 = min_allocator<double>;
- using M = std::flat_map<int, double, std::less<int>, std::vector<int, A1>, std::vector<double, A2>>;
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m[one]), double&);
- assert(m.size() == 7);
- assert(m[1] == 1.5);
- assert(m.size() == 7);
- const int i = 1;
- m[i] = -1.5;
- assert(m[1] == -1.5);
- assert(m.size() == 7);
- assert(m[6] == 0);
- assert(m.size() == 8);
- m[6] = 6.5;
- assert(m[6] == 6.5);
- assert(m.size() == 8);
- }
- {
- std::flat_map<int, double, std::less<>> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ ASSERT_SAME_TYPE(decltype(m[one]), double&);
+ assert(m.size() == 7);
+ assert(m[one] == 1.5);
+ assert(m.size() == 7);
+ m[1] = -1.5;
+ assert(m[1] == -1.5);
+ assert(m.size() == 7);
+ assert(m[6] == 0);
+ assert(m.size() == 8);
+ m[6] = 6.5;
+ assert(m[6] == 6.5);
+ assert(m.size() == 8);
+}
- assert(m.size() == 7);
- assert(m[1] == 1.5);
- assert(m.size() == 7);
- m[1] = -1.5;
- assert(m[1] == -1.5);
- assert(m.size() == 7);
- assert(m[6] == 0);
- assert(m.size() == 8);
- m[6] = 6.5;
- assert(m[6] == 6.5);
- assert(m.size() == 8);
- }
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto index_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
index 0d2c38e805ce62..faacc3cfe8f96f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp
@@ -13,9 +13,11 @@
// mapped_type& operator[](key_type&& k);
#include <flat_map>
+#include <deque>
#include <functional>
#include <cassert>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "MoveOnly.h"
@@ -28,29 +30,10 @@ concept CanIndex = requires(M m, Input k) { m[k]; };
static_assert(CanIndex<std::flat_map<int, double>, int&&>);
static_assert(!CanIndex<std::flat_map<int, NoDefaultCtr>, int&&>);
-int main(int, char**) {
- {
- std::flat_map<MoveOnly, double> m;
- ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
- assert(m.size() == 0);
- assert(m[1] == 0.0);
- assert(m.size() == 1);
- m[1] = -1.5;
- assert(m[1] == -1.5);
- assert(m.size() == 1);
- assert(m[6] == 0);
- assert(m.size() == 2);
- m[6] = 6.5;
- assert(m[6] == 6.5);
- assert(m.size() == 2);
- }
+template <class KeyContainer, class ValueContainer>
+void test() {
{
- std::flat_map< MoveOnly,
- double,
- std::less<>,
- std::vector<MoveOnly, min_allocator<MoveOnly>>,
- std::vector<double, min_allocator<double>>>
- m;
+ std::flat_map<MoveOnly, double, std::less<MoveOnly>, KeyContainer, ValueContainer> m;
ASSERT_SAME_TYPE(decltype(m[MoveOnly{}]), double&);
assert(m.size() == 0);
assert(m[1] == 0.0);
@@ -64,6 +47,13 @@ int main(int, char**) {
assert(m[6] == 6.5);
assert(m.size() == 2);
}
+}
+
+int main(int, char**) {
+ test<std::vector<MoveOnly>, std::vector<double>>();
+ test<std::deque<MoveOnly>, std::vector<double>>();
+ test<MinSequenceContainer<MoveOnly>, MinSequenceContainer<double>>();
+ test<std::vector<MoveOnly, min_allocator<MoveOnly>>, std::vector<double, min_allocator<double>>>();
{
auto index_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
index e23befc0c15d2d..24c08464f3158c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp
@@ -13,9 +13,12 @@
// template<class K> mapped_type& operator[](K&& x);
#include <cassert>
+#include <deque>
#include <flat_map>
#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -46,7 +49,8 @@ static_assert(!CanIndex<const TransparentNoDefaultCtrValueMap, ConvertibleTransp
static_assert(!CanIndex<TransparentMap, TransparentMap::iterator>);
static_assert(!CanIndex<TransparentMap, TransparentMap::const_iterator>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
using P = std::pair<int, double>;
P ar[] = {
P(1, 1.5),
@@ -60,26 +64,8 @@ int main(int, char**) {
const ConvertibleTransparent<int> one{1};
const ConvertibleTransparent<int> six{6};
{
- std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m[one]), double&);
- assert(m.size() == 7);
- assert(m[one] == 1.5);
- assert(m.size() == 7);
- m[one] = -1.5;
- assert(m[one] == -1.5);
- assert(m.size() == 7);
- assert(m[six] == 0);
- assert(m.size() == 8);
- m[six] = 6.5;
- assert(m[six] == 6.5);
- assert(m.size() == 8);
- }
- {
- // allocator
- using A1 = min_allocator<int>;
- using A2 = min_allocator<double>;
- using M = std::flat_map<int, double, TransparentComparator, std::vector<int, A1>, std::vector<double, A2>>;
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ std::flat_map<int, double, TransparentComparator, KeyContainer, ValueContainer> m(
+ ar, ar + sizeof(ar) / sizeof(ar[0]));
ASSERT_SAME_TYPE(decltype(m[one]), double&);
assert(m.size() == 7);
assert(m[one] == 1.5);
@@ -93,22 +79,13 @@ int main(int, char**) {
assert(m[six] == 6.5);
assert(m.size() == 8);
}
- {
- std::flat_map<int, double, TransparentComparator> m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- ASSERT_SAME_TYPE(decltype(m[one]), double&);
+}
- assert(m.size() == 7);
- assert(m[one] == 1.5);
- assert(m.size() == 7);
- m[one] = -1.5;
- assert(m[one] == -1.5);
- assert(m.size() == 7);
- assert(m[six] == 0);
- assert(m.size() == 8);
- m[six] = 6.5;
- assert(m[six] == 6.5);
- assert(m.size() == 8);
- }
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
index 75f1af7ca16d4d..5ecc2cf7c917bd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp
@@ -17,35 +17,31 @@
#include <deque>
#include <functional>
#include <utility>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using M = std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer>;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.empty()), bool);
+ ASSERT_NOEXCEPT(m.empty());
+ assert(m.empty());
+ assert(std::as_const(m).empty());
+ m = {{1, 1.0}};
+ assert(!m.empty());
+ m.clear();
+ assert(m.empty());
+}
+
int main(int, char**) {
- {
- typedef std::flat_map<int, int> M;
- M m;
- ASSERT_SAME_TYPE(decltype(m.empty()), bool);
- ASSERT_NOEXCEPT(m.empty());
- assert(m.empty());
- assert(std::as_const(m).empty());
- m = {{1, 1}};
- assert(!m.empty());
- m.clear();
- assert(m.empty());
- }
- {
- typedef std::flat_map<int, int, std::less<int>, std::deque<int, min_allocator<int>>> M;
- M m;
- ASSERT_SAME_TYPE(decltype(m.empty()), bool);
- ASSERT_NOEXCEPT(m.empty());
- assert(m.empty());
- assert(std::as_const(m).empty());
- m = {{1, 1}};
- assert(!m.empty());
- m.clear();
- assert(m.empty());
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
index b274b2d2704e32..87acdfd2cf6250 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp
@@ -13,12 +13,14 @@
// size_type max_size() const noexcept;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <functional>
#include <limits>
#include <type_traits>
#include <vector>
+#include "MinSequenceContainer.h"
#include "test_allocator.h"
#include "test_macros.h"
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
index a3447026792ed2..957a860450091f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp
@@ -13,35 +13,37 @@
// size_type size() const noexcept;
#include <cassert>
+#include <deque>
#include <flat_map>
+#include <functional>
#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
+#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using M = std::flat_map<int, char, std::less<int>, KeyContainer, ValueContainer>;
{
- using M = std::flat_map<int, char>;
const M m = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
ASSERT_NOEXCEPT(m.size());
assert(m.size() == 3);
}
{
- using M = std::flat_map<int, char>;
const M m = {{1, 'a'}};
ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
ASSERT_NOEXCEPT(m.size());
assert(m.size() == 1);
}
{
- using M = std::flat_map<int, char>;
const M m;
ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
ASSERT_NOEXCEPT(m.size());
assert(m.size() == 0);
}
{
- using M = std::flat_map<int, char>;
M m;
std::size_t s = 1000000;
for (auto i = 0u; i < s; ++i) {
@@ -51,6 +53,13 @@ int main(int, char**) {
ASSERT_NOEXCEPT(m.size());
assert(m.size() == s);
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
index 1d0c8657f78219..06bde71e79941e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp
@@ -20,14 +20,18 @@
#include <ranges>
#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
#include "test_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
{
- using C = std::flat_map<int, int>;
- C m = {{8, 8}, {10, 10}};
+ M m = {{8, 8}, {10, 10}};
assert(m.size() == 2);
m = {{3, 0}, {1, 0}, {2, 0}, {2, 1}, {3, 1}, {4, 0}, {3, 2}, {5, 0}, {6, 0}, {5, 1}};
std::pair<int, int> expected[] = {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}};
@@ -35,37 +39,21 @@ int main(int, char**) {
LIBCPP_ASSERT(std::ranges::equal(m, expected));
}
{
- using C = std::
- flat_map<int, int, std::less<>, std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>;
- C m = {{1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}, {6, 1}, {7, 1}, {8, 1}, {9, 1}, {10, 1}};
- assert(m.size() == 10);
- m = {{1, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 5}, {5, 6}, {2, 7}};
- std::pair<int, int> expected[] = {{1, 1}, {2, 7}, {3, 2}, {4, 3}, {5, 4}, {6, 5}};
- assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
- }
- {
- using C =
- std::flat_map<double,
- int,
- std::less<>,
- std::deque<double, min_allocator<double>>,
- std::vector<int, min_allocator<int>>>;
- C m = {};
- assert(m.size() == 0);
- m = {{3, 0}, {1, 0}, {2, 0}, {2, 1}, {3, 1}, {4, 0}, {3, 2}, {5, 0}, {6, 0}, {5, 1}};
- std::pair<double, int> expected[] = {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}};
- assert(std::ranges::equal(m.keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(m, expected));
- }
- {
- using C = std::flat_map<double, double, std::less<>, std::deque<double>, std::deque<double>>;
- C m = {{10, 1}, {8, 1}};
+ M m = {{10, 1}, {8, 1}};
assert(m.size() == 2);
m = {{3, 2}};
std::pair<double, double> expected[] = {{3, 2}};
assert(std::ranges::equal(m, expected));
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<int>>();
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
index 48a994f877bdb3..b63ce6b19ee165 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp
@@ -25,45 +25,57 @@
#include <functional>
#include <string>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
+#include "min_allocator.h"
-int main(int, char**) {
- {
- using M = std::flat_map<int, char, std::less<int>, std::deque<int>, std::deque<char>>;
- M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
- const M& cm = m;
- ASSERT_SAME_TYPE(decltype(m.begin()), M::iterator);
- ASSERT_SAME_TYPE(decltype(m.cbegin()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(cm.begin()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(m.end()), M::iterator);
- ASSERT_SAME_TYPE(decltype(m.cend()), M::const_iterator);
- ASSERT_SAME_TYPE(decltype(cm.end()), M::const_iterator);
- static_assert(noexcept(m.begin()));
- static_assert(noexcept(cm.begin()));
- static_assert(noexcept(m.cbegin()));
- static_assert(noexcept(m.end()));
- static_assert(noexcept(cm.end()));
- static_assert(noexcept(m.cend()));
- assert(m.size() == 4);
- assert(std::distance(m.begin(), m.end()) == 4);
- assert(std::distance(cm.begin(), cm.end()) == 4);
- assert(std::distance(m.cbegin(), m.cend()) == 4);
- M::iterator i; // default-construct
- i = m.begin(); // move-assignment
- M::const_iterator k = i; // converting constructor
- assert(i == k); // comparison
- for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
- assert(i->first == j); // operator->
- assert(i->second == 'a' + j - 1);
- }
- assert(i == m.end());
- for (int j = 4; j >= 1; --j) {
- --i; // pre-decrement
- assert((*i).first == j);
- assert((*i).second == 'a' + j - 1);
- }
- assert(i == m.begin());
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+ const M& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.begin()), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(m.cbegin()), typename M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.begin()), typename M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.end()), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(m.cend()), typename M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(cm.end()), typename M::const_iterator);
+ static_assert(noexcept(m.begin()));
+ static_assert(noexcept(cm.begin()));
+ static_assert(noexcept(m.cbegin()));
+ static_assert(noexcept(m.end()));
+ static_assert(noexcept(cm.end()));
+ static_assert(noexcept(m.cend()));
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(std::distance(cm.begin(), cm.end()) == 4);
+ assert(std::distance(m.cbegin(), m.cend()) == 4);
+ typename M::iterator i; // default-construct
+ i = m.begin(); // move-assignment
+ typename M::const_iterator k = i; // converting constructor
+ assert(i == k); // comparison
+ for (int j = 1; j <= 4; ++j, ++i) { // pre-increment
+ assert(i->first == j); // operator->
+ assert(i->second == 'a' + j - 1);
}
+ assert(i == m.end());
+ for (int j = 4; j >= 1; --j) {
+ --i; // pre-decrement
+ assert((*i).first == j);
+ assert((*i).second == 'a' + j - 1);
+ }
+ assert(i == m.begin());
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
{
// N3644 testing
using C = std::flat_map<int, char>;
@@ -79,5 +91,6 @@ int main(int, char**) {
assert(!(ii1 != cii));
assert(!(cii != ii1));
}
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
index 0a7e608ae57b16..db7c6dd340f837 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -19,85 +19,56 @@
#include <string>
#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
+#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
void test() {
- {
- using C = std::flat_map<int, char>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
- using CRI = C::const_reverse_iterator;
- static_assert(std::random_access_iterator<I>);
- static_assert(std::random_access_iterator<CI>);
- static_assert(std::random_access_iterator<RI>);
- static_assert(std::random_access_iterator<CRI>);
- static_assert(!std::contiguous_iterator<I>);
- static_assert(!std::contiguous_iterator<CI>);
- static_assert(!std::contiguous_iterator<RI>);
- static_assert(!std::contiguous_iterator<CRI>);
- static_assert(!std::indirectly_writable<I, std::pair<int, char>>);
- static_assert(!std::indirectly_writable<CI, std::pair<int, char>>);
- static_assert(!std::indirectly_writable<RI, std::pair<int, char>>);
- static_assert(!std::indirectly_writable<CRI, std::pair<int, char>>);
- static_assert(std::sentinel_for<I, I>);
- static_assert(std::sentinel_for<I, CI>);
- static_assert(!std::sentinel_for<I, RI>);
- static_assert(!std::sentinel_for<I, CRI>);
- static_assert(std::sentinel_for<CI, I>);
- static_assert(std::sentinel_for<CI, CI>);
- static_assert(!std::sentinel_for<CI, RI>);
- static_assert(!std::sentinel_for<CI, CRI>);
- static_assert(!std::sentinel_for<RI, I>);
- static_assert(!std::sentinel_for<RI, CI>);
- static_assert(std::sentinel_for<RI, RI>);
- static_assert(std::sentinel_for<RI, CRI>);
- static_assert(!std::sentinel_for<CRI, I>);
- static_assert(!std::sentinel_for<CRI, CI>);
- static_assert(std::sentinel_for<CRI, RI>);
- static_assert(std::sentinel_for<CRI, CRI>);
- static_assert(std::indirectly_movable_storable<I, std::pair<int, char>*>);
- static_assert(std::indirectly_movable_storable<CI, std::pair<int, char>*>);
- static_assert(std::indirectly_movable_storable<RI, std::pair<int, char>*>);
- static_assert(std::indirectly_movable_storable<CRI, std::pair<int, char>*>);
- }
- {
- using C = std::flat_map<char*, int, std::less<>, std::deque<char*>, std::vector<int>>;
- using I = C::iterator;
- using CI = C::const_iterator;
- using RI = C::reverse_iterator;
- using CRI = C::const_reverse_iterator;
- static_assert(std::random_access_iterator<I>);
- static_assert(std::random_access_iterator<CI>);
- static_assert(std::random_access_iterator<RI>);
- static_assert(std::random_access_iterator<CRI>);
- static_assert(!std::contiguous_iterator<I>);
- static_assert(!std::contiguous_iterator<CI>);
- static_assert(!std::contiguous_iterator<RI>);
- static_assert(!std::contiguous_iterator<CRI>);
- static_assert(!std::indirectly_writable<I, std::pair<char*, int>>);
- static_assert(!std::indirectly_writable<CI, std::pair<char*, int>>);
- static_assert(!std::indirectly_writable<RI, std::pair<char*, int>>);
- static_assert(!std::indirectly_writable<CRI, std::pair<char*, int>>);
- static_assert(std::sentinel_for<I, I>);
- static_assert(std::sentinel_for<I, CI>);
- static_assert(!std::sentinel_for<I, RI>);
- static_assert(!std::sentinel_for<I, CRI>);
- static_assert(std::sentinel_for<CI, I>);
- static_assert(std::sentinel_for<CI, CI>);
- static_assert(!std::sentinel_for<CI, RI>);
- static_assert(!std::sentinel_for<CI, CRI>);
- static_assert(!std::sentinel_for<RI, I>);
- static_assert(!std::sentinel_for<RI, CI>);
- static_assert(std::sentinel_for<RI, RI>);
- static_assert(std::sentinel_for<RI, CRI>);
- static_assert(!std::sentinel_for<CRI, I>);
- static_assert(!std::sentinel_for<CRI, CI>);
- static_assert(std::sentinel_for<CRI, RI>);
- static_assert(std::sentinel_for<CRI, CRI>);
- static_assert(std::indirectly_movable_storable<I, std::pair<char*, int>*>);
- static_assert(std::indirectly_movable_storable<CI, std::pair<char*, int>*>);
- static_assert(std::indirectly_movable_storable<RI, std::pair<char*, int>*>);
- static_assert(std::indirectly_movable_storable<CRI, std::pair<char*, int>*>);
- }
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using C = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using I = C::iterator;
+ using CI = C::const_iterator;
+ using RI = C::reverse_iterator;
+ using CRI = C::const_reverse_iterator;
+ static_assert(std::random_access_iterator<I>);
+ static_assert(std::random_access_iterator<CI>);
+ static_assert(std::random_access_iterator<RI>);
+ static_assert(std::random_access_iterator<CRI>);
+ static_assert(!std::contiguous_iterator<I>);
+ static_assert(!std::contiguous_iterator<CI>);
+ static_assert(!std::contiguous_iterator<RI>);
+ static_assert(!std::contiguous_iterator<CRI>);
+ static_assert(!std::indirectly_writable<I, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<CI, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<RI, std::pair<int, char>>);
+ static_assert(!std::indirectly_writable<CRI, std::pair<int, char>>);
+ static_assert(std::sentinel_for<I, I>);
+ static_assert(std::sentinel_for<I, CI>);
+ static_assert(!std::sentinel_for<I, RI>);
+ static_assert(!std::sentinel_for<I, CRI>);
+ static_assert(std::sentinel_for<CI, I>);
+ static_assert(std::sentinel_for<CI, CI>);
+ static_assert(!std::sentinel_for<CI, RI>);
+ static_assert(!std::sentinel_for<CI, CRI>);
+ static_assert(!std::sentinel_for<RI, I>);
+ static_assert(!std::sentinel_for<RI, CI>);
+ static_assert(std::sentinel_for<RI, RI>);
+ static_assert(std::sentinel_for<RI, CRI>);
+ static_assert(!std::sentinel_for<CRI, I>);
+ static_assert(!std::sentinel_for<CRI, CI>);
+ static_assert(std::sentinel_for<CRI, RI>);
+ static_assert(std::sentinel_for<CRI, CRI>);
+ static_assert(std::indirectly_movable_storable<I, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<CI, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<RI, std::pair<int, char>*>);
+ static_assert(std::indirectly_movable_storable<CRI, std::pair<int, char>*>);
+}
+
+void test() {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
index ae1434ad6bd87c..abbad310f49caf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp
@@ -15,12 +15,17 @@
#include <ranges>
#include <string>
#include <vector>
+#include "MinSequenceContainer.h"
+#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
void test() {
{
- using C = std::flat_map<int, int, std::deque<int>, std::vector<int>>;
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using C = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
- static_assert(std::same_as<std::ranges::iterator_t<C>, C::iterator>);
+ static_assert(std::same_as<std::ranges::iterator_t<C>, typename C::iterator>);
static_assert(std::ranges::random_access_range<C>);
static_assert(!std::ranges::contiguous_range<C>);
static_assert(std::ranges::common_range<C>);
@@ -30,7 +35,7 @@ void test() {
static_assert(!std::ranges::borrowed_range<C>);
static_assert(std::ranges::viewable_range<C>);
- static_assert(std::same_as<std::ranges::iterator_t<const C>, C::const_iterator>);
+ static_assert(std::same_as<std::ranges::iterator_t<const C>, typename C::const_iterator>);
static_assert(std::ranges::random_access_range<const C>);
static_assert(!std::ranges::contiguous_range<const C>);
static_assert(std::ranges::common_range<const C>);
@@ -41,3 +46,10 @@ void test() {
static_assert(!std::ranges::viewable_range<const C>);
}
}
+
+void test() {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
index c3562013470aeb..4ae8800e99c92e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
@@ -20,6 +20,7 @@
#include <functional>
#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -35,41 +36,27 @@ static_assert(NoExceptClear<std::flat_map<int, int>>);
static_assert(
NoExceptClear<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ M m = {{1, 2}, {2, 1}, {3, 3}, {4, 1}, {5, 0}};
+ assert(m.size() == 5);
+ ASSERT_NOEXCEPT(m.clear());
+ ASSERT_SAME_TYPE(decltype(m.clear()), void);
+ m.clear();
+ assert(m.size() == 0);
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, int>;
- M m = {{1, 2}, {2, 1}, {3, 3}, {4, 1}, {5, 0}};
- assert(m.size() == 5);
- ASSERT_NOEXCEPT(m.clear());
- ASSERT_SAME_TYPE(decltype(m.clear()), void);
- m.clear();
- assert(m.size() == 0);
- }
- {
- using M =
- std::flat_map<int,
- int,
- std::greater<int>,
- std::deque<int, min_allocator<int>>,
- std::vector<int, min_allocator<int>>>;
- M m = {{1, 2}, {2, 1}, {3, 3}, {4, 1}, {5, 0}};
- assert(m.size() == 5);
- ASSERT_NOEXCEPT(m.clear());
- ASSERT_SAME_TYPE(decltype(m.clear()), void);
- m.clear();
- assert(m.size() == 0);
- }
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- M m = {{true, false}, {false, true}};
- assert(m.size() == 2);
- ASSERT_NOEXCEPT(m.clear());
- ASSERT_SAME_TYPE(decltype(m.clear()), void);
- m.clear();
- assert(m.size() == 0);
- }
-#endif
+ test<std::vector<int>, std::vector<int>>();
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
index cfcc786e61edbb..06631ac689f75d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp
@@ -17,7 +17,10 @@
#include <cassert>
#include <deque>
#include <tuple>
+#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "../../../Emplaceable.h"
@@ -35,90 +38,59 @@ static_assert(CanEmplace<Map, std::piecewise_construct_t, std::tuple<int, double
static_assert(!CanEmplace<Map, Emplaceable>);
static_assert(!CanEmplace<Map, int, double>);
+template <class KeyContainer, class ValueContainer>
+void test_simple() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using R = std::pair<typename M::iterator, bool>;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ R r = m.emplace(typename M::value_type(2, 3.5));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+}
+
+template <class KeyContainer, class ValueContainer>
+void test_emplaceable() {
+ using M = std::flat_map<int, Emplaceable, std::less<int>, KeyContainer, ValueContainer>;
+ using R = std::pair<typename M::iterator, bool>;
+
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace()), R);
+ R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(!r.second);
+ assert(r.first == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+}
+
int main(int, char**) {
- {
- // Emplaceable
- using M = std::flat_map<int, Emplaceable>;
- using R = std::pair<M::iterator, bool>;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace()), R);
- R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == Emplaceable());
- r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(!r.second);
- assert(r.first == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- }
- {
- using M = std::flat_map<int, double>;
- using R = std::pair<M::iterator, bool>;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace()), R);
- R r = m.emplace(M::value_type(2, 3.5));
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 3.5);
- }
- {
- using M =
- std::flat_map<int,
- Emplaceable,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<Emplaceable, min_allocator<Emplaceable>>>;
- using R = std::pair<M::iterator, bool>;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace()), R);
- R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == Emplaceable());
- r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(!r.second);
- assert(r.first == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- }
- {
- using M =
- std::flat_map< int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- using R = std::pair<M::iterator, bool>;
- M m;
- R r = m.emplace(M::value_type(2, 3.5));
- ASSERT_SAME_TYPE(decltype(m.emplace()), R);
- assert(r.second);
- assert(r.first == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 3.5);
- }
+ test_simple<std::vector<int>, std::vector<double>>();
+ test_simple<std::deque<int>, std::vector<double>>();
+ test_simple<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test_simple<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
+ test_emplaceable<std::vector<int>, std::vector<Emplaceable>>();
+ test_emplaceable<std::deque<int>, std::vector<Emplaceable>>();
+ test_emplaceable<MinSequenceContainer<int>, MinSequenceContainer<Emplaceable>>();
+ test_emplaceable<std::vector<int, min_allocator<int>>, std::vector<Emplaceable, min_allocator<Emplaceable>>>();
{
auto emplace_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
index bad175e299d37b..cfee6cac5806cc 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp
@@ -16,7 +16,10 @@
#include <flat_map>
#include <cassert>
#include <deque>
+#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "../../../Emplaceable.h"
#include "DefaultOnly.h"
@@ -38,81 +41,55 @@ static_assert(!CanEmplaceHint<Map, Emplaceable>);
static_assert(!CanEmplaceHint<Map, int, double>);
#endif
+template <class KeyContainer, class ValueContainer>
+void test_simple() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using R = M::iterator;
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), typename M::value_type(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 3.5);
+}
+
+template <class KeyContainer, class ValueContainer>
+void test_emplaceable() {
+ using M = std::flat_map<int, Emplaceable, std::less<int>, KeyContainer, ValueContainer>;
+ using R = M::iterator;
+
+ M m;
+ ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
+ R r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
+ assert(r == m.begin());
+ assert(m.size() == 1);
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == Emplaceable());
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+ r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
+ assert(r == m.begin());
+ assert(m.size() == 2);
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == Emplaceable(2, 3.5));
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, Emplaceable>;
- using R = M::iterator;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
- R r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
- assert(r == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == Emplaceable());
- r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- }
- {
- using M = std::flat_map<int, double>;
- using R = M::iterator;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
- R r = m.emplace_hint(m.end(), M::value_type(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 3.5);
- }
- {
- using M =
- std::flat_map<int,
- Emplaceable,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<Emplaceable, min_allocator<Emplaceable>>>;
- using R = M::iterator;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
- R r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple());
- assert(r == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == Emplaceable());
- r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- r = m.emplace_hint(m.end(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 2);
- assert(m.begin()->first == 1);
- assert(m.begin()->second == Emplaceable(2, 3.5));
- }
- {
- using M =
- std::flat_map< int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- using R = M::iterator;
- M m;
- ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R);
- R r = m.emplace_hint(m.end(), M::value_type(2, 3.5));
- assert(r == m.begin());
- assert(m.size() == 1);
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 3.5);
- }
+ test_simple<std::vector<int>, std::vector<double>>();
+ test_simple<std::deque<int>, std::vector<double>>();
+ test_simple<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test_simple<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
+ test_emplaceable<std::vector<int>, std::vector<Emplaceable>>();
+ test_emplaceable<std::deque<int>, std::vector<Emplaceable>>();
+ test_emplaceable<MinSequenceContainer<int>, MinSequenceContainer<Emplaceable>>();
+ test_emplaceable<std::vector<int, min_allocator<int>>, std::vector<Emplaceable, min_allocator<Emplaceable>>>();
{
auto emplace_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
index 8799caf83f4bec..914e8b676a6568 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp
@@ -19,227 +19,129 @@
#include <flat_map>
#include <functional>
#include <utility>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using P = std::pair<Key, Value>;
+ using I = M::iterator;
+
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3));
+ assert(m.size() == 7);
+ assert(i1 == std::next(m.begin(), 3));
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 5);
+ assert(std::next(m.begin(), 3)->second == 5.5);
+ assert(std::next(m.begin(), 4)->first == 6);
+ assert(std::next(m.begin(), 4)->second == 6.5);
+ assert(std::next(m.begin(), 5)->first == 7);
+ assert(std::next(m.begin(), 5)->second == 7.5);
+ assert(std::next(m.begin(), 6)->first == 8);
+ assert(std::next(m.begin(), 6)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
+
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5));
+ assert(m.size() == 5);
+ assert(i3 == m.end());
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 3);
+ assert(std::next(m.begin())->second == 3.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
+ assert(m.size() == 4);
+ assert(i4 == std::next(m.begin()));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 6);
+ assert(std::next(m.begin(), 2)->second == 6.5);
+ assert(std::next(m.begin(), 3)->first == 7);
+ assert(std::next(m.begin(), 3)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
+ assert(m.size() == 3);
+ assert(i5 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+ assert(std::next(m.begin(), 2)->first == 7);
+ assert(std::next(m.begin(), 2)->second == 7.5);
+
+ std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
+ assert(m.size() == 2);
+ assert(i6 == std::next(m.begin(), 2));
+ assert(m.begin()->first == 2);
+ assert(m.begin()->second == 2.5);
+ assert(std::next(m.begin())->first == 5);
+ assert(std::next(m.begin())->second == 5.5);
+
+ std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
+ assert(m.size() == 1);
+ assert(i7 == std::next(m.begin(), 0));
+ assert(m.begin()->first == 5);
+ assert(m.begin()->second == 5.5);
+
+ std::same_as<I> decltype(auto) i8 = m.erase(m.begin());
+ assert(m.size() == 0);
+ assert(i8 == m.begin());
+ assert(i8 == m.end());
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, double>;
- using P = std::pair<int, double>;
- using I = typename M::iterator;
- P ar[] = {
- P(1, 1.5),
- P(2, 2.5),
- P(3, 3.5),
- P(4, 4.5),
- P(5, 5.5),
- P(6, 6.5),
- P(7, 7.5),
- P(8, 8.5),
- };
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- assert(m.size() == 8);
- std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3));
- assert(m.size() == 7);
- assert(i1 == std::next(m.begin(), 3));
- assert(m.begin()->first == 1);
- assert(m.begin()->second == 1.5);
- assert(std::next(m.begin())->first == 2);
- assert(std::next(m.begin())->second == 2.5);
- assert(std::next(m.begin(), 2)->first == 3);
- assert(std::next(m.begin(), 2)->second == 3.5);
- assert(std::next(m.begin(), 3)->first == 5);
- assert(std::next(m.begin(), 3)->second == 5.5);
- assert(std::next(m.begin(), 4)->first == 6);
- assert(std::next(m.begin(), 4)->second == 6.5);
- assert(std::next(m.begin(), 5)->first == 7);
- assert(std::next(m.begin(), 5)->second == 7.5);
- assert(std::next(m.begin(), 6)->first == 8);
- assert(std::next(m.begin(), 6)->second == 8.5);
-
- std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
- assert(m.size() == 6);
- assert(i2 == m.begin());
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 3);
- assert(std::next(m.begin())->second == 3.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
- assert(std::next(m.begin(), 5)->first == 8);
- assert(std::next(m.begin(), 5)->second == 8.5);
-
- std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5));
- assert(m.size() == 5);
- assert(i3 == m.end());
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 3);
- assert(std::next(m.begin())->second == 3.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
-
- std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
- assert(m.size() == 4);
- assert(i4 == std::next(m.begin()));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
- assert(std::next(m.begin(), 2)->first == 6);
- assert(std::next(m.begin(), 2)->second == 6.5);
- assert(std::next(m.begin(), 3)->first == 7);
- assert(std::next(m.begin(), 3)->second == 7.5);
-
- std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
- assert(m.size() == 3);
- assert(i5 == std::next(m.begin(), 2));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
- assert(std::next(m.begin(), 2)->first == 7);
- assert(std::next(m.begin(), 2)->second == 7.5);
-
- std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
- assert(m.size() == 2);
- assert(i6 == std::next(m.begin(), 2));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
-
- std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
- assert(m.size() == 1);
- assert(i7 == std::next(m.begin(), 0));
- assert(m.begin()->first == 5);
- assert(m.begin()->second == 5.5);
-
- std::same_as<I> decltype(auto) i8 = m.erase(m.begin());
- assert(m.size() == 0);
- assert(i8 == m.begin());
- assert(i8 == m.end());
- }
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>;
- using P = std::pair<int, double>;
- using I = typename M::iterator;
- P ar[] = {
- P(1, 1.5),
- P(2, 2.5),
- P(3, 3.5),
- P(4, 4.5),
- P(5, 5.5),
- P(6, 6.5),
- P(7, 7.5),
- P(8, 8.5),
- };
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- assert(m.size() == 8);
- std::same_as<I> decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3));
- assert(m.size() == 7);
- assert(i1 == std::next(m.begin(), 3));
- assert(m.begin()->first == 1);
- assert(m.begin()->second == 1.5);
- assert(std::next(m.begin())->first == 2);
- assert(std::next(m.begin())->second == 2.5);
- assert(std::next(m.begin(), 2)->first == 3);
- assert(std::next(m.begin(), 2)->second == 3.5);
- assert(std::next(m.begin(), 3)->first == 5);
- assert(std::next(m.begin(), 3)->second == 5.5);
- assert(std::next(m.begin(), 4)->first == 6);
- assert(std::next(m.begin(), 4)->second == 6.5);
- assert(std::next(m.begin(), 5)->first == 7);
- assert(std::next(m.begin(), 5)->second == 7.5);
- assert(std::next(m.begin(), 6)->first == 8);
- assert(std::next(m.begin(), 6)->second == 8.5);
-
- std::same_as<I> decltype(auto) i2 = m.erase(std::next(m.begin(), 0));
- assert(m.size() == 6);
- assert(i2 == m.begin());
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 3);
- assert(std::next(m.begin())->second == 3.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
- assert(std::next(m.begin(), 5)->first == 8);
- assert(std::next(m.begin(), 5)->second == 8.5);
-
- std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5));
- assert(m.size() == 5);
- assert(i3 == m.end());
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 3);
- assert(std::next(m.begin())->second == 3.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
-
- std::same_as<I> decltype(auto) i4 = m.erase(std::next(m.begin(), 1));
- assert(m.size() == 4);
- assert(i4 == std::next(m.begin()));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
- assert(std::next(m.begin(), 2)->first == 6);
- assert(std::next(m.begin(), 2)->second == 6.5);
- assert(std::next(m.begin(), 3)->first == 7);
- assert(std::next(m.begin(), 3)->second == 7.5);
-
- std::same_as<I> decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2));
- assert(m.size() == 3);
- assert(i5 == std::next(m.begin(), 2));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
- assert(std::next(m.begin(), 2)->first == 7);
- assert(std::next(m.begin(), 2)->second == 7.5);
-
- std::same_as<I> decltype(auto) i6 = m.erase(std::next(m.begin(), 2));
- assert(m.size() == 2);
- assert(i6 == std::next(m.begin(), 2));
- assert(m.begin()->first == 2);
- assert(m.begin()->second == 2.5);
- assert(std::next(m.begin())->first == 5);
- assert(std::next(m.begin())->second == 5.5);
-
- std::same_as<I> decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0));
- assert(m.size() == 1);
- assert(i7 == std::next(m.begin(), 0));
- assert(m.begin()->first == 5);
- assert(m.begin()->second == 5.5);
-
- std::same_as<I> decltype(auto) i8 = m.erase(m.begin());
- assert(m.size() == 0);
- assert(i8 == m.begin());
- assert(i8 == m.end());
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
{
auto erase_function = [](auto& m, auto) { m.erase(m.begin() + 2); };
test_erase_exception_guarantee(erase_function);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
index 3ac2115e716e86..0bc92082940291 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp
@@ -18,147 +18,88 @@
#include <flat_map>
#include <functional>
#include <utility>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
- {
- using M = std::flat_map<int, double>;
- using P = std::pair<int, double>;
- using I = M::iterator;
- P ar[] = {
- P(1, 1.5),
- P(2, 2.5),
- P(3, 3.5),
- P(4, 4.5),
- P(5, 5.5),
- P(6, 6.5),
- P(7, 7.5),
- P(8, 8.5),
- };
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- assert(m.size() == 8);
- std::same_as<I> decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin());
- assert(m.size() == 8);
- assert(i1 == m.begin());
- assert(m.begin()->first == 1);
- assert(m.begin()->second == 1.5);
- assert(std::next(m.begin())->first == 2);
- assert(std::next(m.begin())->second == 2.5);
- assert(std::next(m.begin(), 2)->first == 3);
- assert(std::next(m.begin(), 2)->second == 3.5);
- assert(std::next(m.begin(), 3)->first == 4);
- assert(std::next(m.begin(), 3)->second == 4.5);
- assert(std::next(m.begin(), 4)->first == 5);
- assert(std::next(m.begin(), 4)->second == 5.5);
- assert(std::next(m.begin(), 5)->first == 6);
- assert(std::next(m.begin(), 5)->second == 6.5);
- assert(std::next(m.begin(), 6)->first == 7);
- assert(std::next(m.begin(), 6)->second == 7.5);
- assert(std::next(m.begin(), 7)->first == 8);
- assert(std::next(m.begin(), 7)->second == 8.5);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using P = std::pair<Key, Value>;
+ using I = M::iterator;
- std::same_as<I> decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2));
- assert(m.size() == 6);
- assert(i2 == m.begin());
- assert(std::next(m.begin(), 0)->first == 3);
- assert(std::next(m.begin(), 0)->second == 3.5);
- assert(std::next(m.begin(), 1)->first == 4);
- assert(std::next(m.begin(), 1)->second == 4.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
- assert(std::next(m.begin(), 5)->first == 8);
- assert(std::next(m.begin(), 5)->second == 8.5);
+ P ar[] = {
+ P(1, 1.5),
+ P(2, 2.5),
+ P(3, 3.5),
+ P(4, 4.5),
+ P(5, 5.5),
+ P(6, 6.5),
+ P(7, 7.5),
+ P(8, 8.5),
+ };
+ M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+ assert(m.size() == 8);
+ std::same_as<I> decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin());
+ assert(m.size() == 8);
+ assert(i1 == m.begin());
+ assert(m.begin()->first == 1);
+ assert(m.begin()->second == 1.5);
+ assert(std::next(m.begin())->first == 2);
+ assert(std::next(m.begin())->second == 2.5);
+ assert(std::next(m.begin(), 2)->first == 3);
+ assert(std::next(m.begin(), 2)->second == 3.5);
+ assert(std::next(m.begin(), 3)->first == 4);
+ assert(std::next(m.begin(), 3)->second == 4.5);
+ assert(std::next(m.begin(), 4)->first == 5);
+ assert(std::next(m.begin(), 4)->second == 5.5);
+ assert(std::next(m.begin(), 5)->first == 6);
+ assert(std::next(m.begin(), 5)->second == 6.5);
+ assert(std::next(m.begin(), 6)->first == 7);
+ assert(std::next(m.begin(), 6)->second == 7.5);
+ assert(std::next(m.begin(), 7)->first == 8);
+ assert(std::next(m.begin(), 7)->second == 8.5);
- std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6));
- assert(m.size() == 2);
- assert(i3 == std::next(m.begin(), 2));
- assert(std::next(m.begin(), 0)->first == 3);
- assert(std::next(m.begin(), 0)->second == 3.5);
- assert(std::next(m.begin(), 1)->first == 4);
- assert(std::next(m.begin(), 1)->second == 4.5);
-
- std::same_as<I> decltype(auto) i4 = m.erase(m.cbegin(), m.cend());
- assert(m.size() == 0);
- assert(i4 == m.begin());
- assert(i4 == m.end());
- }
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>;
- using P = std::pair<int, double>;
- using I = typename M::iterator;
- P ar[] = {
- P(1, 1.5),
- P(2, 2.5),
- P(3, 3.5),
- P(4, 4.5),
- P(5, 5.5),
- P(6, 6.5),
- P(7, 7.5),
- P(8, 8.5),
- };
- M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
- assert(m.size() == 8);
- std::same_as<I> decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin());
- assert(m.size() == 8);
- assert(i1 == m.begin());
- assert(m.begin()->first == 1);
- assert(m.begin()->second == 1.5);
- assert(std::next(m.begin())->first == 2);
- assert(std::next(m.begin())->second == 2.5);
- assert(std::next(m.begin(), 2)->first == 3);
- assert(std::next(m.begin(), 2)->second == 3.5);
- assert(std::next(m.begin(), 3)->first == 4);
- assert(std::next(m.begin(), 3)->second == 4.5);
- assert(std::next(m.begin(), 4)->first == 5);
- assert(std::next(m.begin(), 4)->second == 5.5);
- assert(std::next(m.begin(), 5)->first == 6);
- assert(std::next(m.begin(), 5)->second == 6.5);
- assert(std::next(m.begin(), 6)->first == 7);
- assert(std::next(m.begin(), 6)->second == 7.5);
- assert(std::next(m.begin(), 7)->first == 8);
- assert(std::next(m.begin(), 7)->second == 8.5);
+ std::same_as<I> decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2));
+ assert(m.size() == 6);
+ assert(i2 == m.begin());
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
+ assert(std::next(m.begin(), 2)->first == 5);
+ assert(std::next(m.begin(), 2)->second == 5.5);
+ assert(std::next(m.begin(), 3)->first == 6);
+ assert(std::next(m.begin(), 3)->second == 6.5);
+ assert(std::next(m.begin(), 4)->first == 7);
+ assert(std::next(m.begin(), 4)->second == 7.5);
+ assert(std::next(m.begin(), 5)->first == 8);
+ assert(std::next(m.begin(), 5)->second == 8.5);
- std::same_as<I> decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2));
- assert(m.size() == 6);
- assert(i2 == m.begin());
- assert(std::next(m.begin(), 0)->first == 3);
- assert(std::next(m.begin(), 0)->second == 3.5);
- assert(std::next(m.begin(), 1)->first == 4);
- assert(std::next(m.begin(), 1)->second == 4.5);
- assert(std::next(m.begin(), 2)->first == 5);
- assert(std::next(m.begin(), 2)->second == 5.5);
- assert(std::next(m.begin(), 3)->first == 6);
- assert(std::next(m.begin(), 3)->second == 6.5);
- assert(std::next(m.begin(), 4)->first == 7);
- assert(std::next(m.begin(), 4)->second == 7.5);
- assert(std::next(m.begin(), 5)->first == 8);
- assert(std::next(m.begin(), 5)->second == 8.5);
+ std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6));
+ assert(m.size() == 2);
+ assert(i3 == std::next(m.begin(), 2));
+ assert(std::next(m.begin(), 0)->first == 3);
+ assert(std::next(m.begin(), 0)->second == 3.5);
+ assert(std::next(m.begin(), 1)->first == 4);
+ assert(std::next(m.begin(), 1)->second == 4.5);
- std::same_as<I> decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6));
- assert(m.size() == 2);
- assert(i3 == std::next(m.begin(), 2));
- assert(std::next(m.begin(), 0)->first == 3);
- assert(std::next(m.begin(), 0)->second == 3.5);
- assert(std::next(m.begin(), 1)->first == 4);
- assert(std::next(m.begin(), 1)->second == 4.5);
+ std::same_as<I> decltype(auto) i4 = m.erase(m.cbegin(), m.cend());
+ assert(m.size() == 0);
+ assert(i4 == m.begin());
+ assert(i4 == m.end());
+}
- std::same_as<I> decltype(auto) i4 = m.erase(m.cbegin(), m.cend());
- assert(m.size() == 0);
- assert(i4 == m.begin());
- assert(i4 == m.end());
- }
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto erase_function = [](auto& m, auto) { m.erase(m.begin(), m.begin() + 2); };
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
index d23801d0689e67..ef57b1cb5512d5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
@@ -18,98 +18,65 @@
#include <flat_map>
#include <functional>
#include <utility>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer, class Compare = std::less<>>
+void test() {
+ using M = std::flat_map<int, char, Compare, KeyContainer, ValueContainer>;
+
+ auto make = [](std::initializer_list<int> il) {
+ M m;
+ for (int i : il) {
+ m.emplace(i, i);
+ }
+ return m;
+ };
+ M m = make({1, 2, 3, 4, 5, 6, 7, 8});
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), typename M::size_type);
+ auto n = m.erase(9);
+ assert(n == 0);
+ assert(m == make({1, 2, 3, 4, 5, 6, 7, 8}));
+ n = m.erase(4);
+ assert(n == 1);
+ assert(m == make({1, 2, 3, 5, 6, 7, 8}));
+ n = m.erase(1);
+ assert(n == 1);
+ assert(m == make({2, 3, 5, 6, 7, 8}));
+ n = m.erase(8);
+ assert(n == 1);
+ assert(m == make({2, 3, 5, 6, 7}));
+ n = m.erase(3);
+ assert(n == 1);
+ assert(m == make({2, 5, 6, 7}));
+ n = m.erase(4);
+ assert(n == 0);
+ assert(m == make({2, 5, 6, 7}));
+ n = m.erase(6);
+ assert(n == 1);
+ assert(m == make({2, 5, 7}));
+ n = m.erase(7);
+ assert(n == 1);
+ assert(m == make({2, 5}));
+ n = m.erase(2);
+ assert(n == 1);
+ assert(m == make({5}));
+ n = m.erase(5);
+ assert(n == 1);
+ assert(m.empty());
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, char>;
- auto make = [](std::initializer_list<int> il) {
- M m;
- for (int i : il) {
- m.emplace(i, i);
- }
- return m;
- };
- M m = make({1, 2, 3, 4, 5, 6, 7, 8});
- ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
- auto n = m.erase(9);
- assert(n == 0);
- assert(m == make({1, 2, 3, 4, 5, 6, 7, 8}));
- n = m.erase(4);
- assert(n == 1);
- assert(m == make({1, 2, 3, 5, 6, 7, 8}));
- n = m.erase(1);
- assert(n == 1);
- assert(m == make({2, 3, 5, 6, 7, 8}));
- n = m.erase(8);
- assert(n == 1);
- assert(m == make({2, 3, 5, 6, 7}));
- n = m.erase(3);
- assert(n == 1);
- assert(m == make({2, 5, 6, 7}));
- n = m.erase(4);
- assert(n == 0);
- assert(m == make({2, 5, 6, 7}));
- n = m.erase(6);
- assert(n == 1);
- assert(m == make({2, 5, 7}));
- n = m.erase(7);
- assert(n == 1);
- assert(m == make({2, 5}));
- n = m.erase(2);
- assert(n == 1);
- assert(m == make({5}));
- n = m.erase(5);
- assert(n == 1);
- assert(m.empty());
- }
- {
- using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
- auto make = [](std::initializer_list<int> il) {
- M m;
- for (int i : il) {
- m.emplace(i, i);
- }
- return m;
- };
- M::key_container_type container = {5, 6, 7, 8};
- container.insert(container.begin(), {1, 2, 3, 4});
- M m = M(std::move(container), {1, 2, 3, 4, 5, 6, 7, 8});
- ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
- auto n = m.erase(9);
- assert(n == 0);
- assert(m == make({1, 2, 3, 4, 5, 6, 7, 8}));
- n = m.erase(4);
- assert(n == 1);
- assert(m == make({1, 2, 3, 5, 6, 7, 8}));
- n = m.erase(1);
- assert(n == 1);
- assert(m == make({2, 3, 5, 6, 7, 8}));
- n = m.erase(8);
- assert(n == 1);
- assert(m == make({2, 3, 5, 6, 7}));
- n = m.erase(3);
- assert(n == 1);
- assert(m == make({2, 5, 6, 7}));
- n = m.erase(4);
- assert(n == 0);
- assert(m == make({2, 5, 6, 7}));
- n = m.erase(6);
- assert(n == 1);
- assert(m == make({2, 5, 7}));
- n = m.erase(7);
- assert(n == 1);
- assert(m == make({2, 5}));
- n = m.erase(2);
- assert(n == 1);
- assert(m == make({5}));
- n = m.erase(5);
- assert(n == 1);
- assert(m.empty());
- }
+ test<std::vector<int>, std::vector<char>>();
+ test<std::vector<int>, std::vector<char>, std::greater<>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
{
auto erase_function = [](auto& m, auto key_arg) {
using Map = std::decay_t<decltype(m)>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
index 296e8c2da41611..3ba30757bf2c7d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp
@@ -19,7 +19,9 @@
#include <functional>
#include <string>
#include <utility>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
@@ -47,68 +49,56 @@ struct HeterogeneousKey {
It it_;
};
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.erase(Transparent<std::string>{"abc"})), M::size_type);
+template <class KeyContainer, class ValueContainer>
+void test_simple() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
- auto n = m.erase(Transparent<std::string>{"epsilon"});
- assert(n == 1);
+ M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
+ ASSERT_SAME_TYPE(decltype(m.erase(9)), typename M::size_type);
+ auto n = m.erase(3); // erase(K&&) [with K=int]
+ assert(n == 1);
+ assert((m == M{{1, 1}, {2, 2}, {4, 4}}));
+ typename M::key_type lvalue = 2;
+ n = m.erase(lvalue); // erase(K&&) [with K=int&]
+ assert(n == 1);
+ assert((m == M{{1, 1}, {4, 4}}));
+ const typename M::key_type const_lvalue = 1;
+ n = m.erase(const_lvalue); // erase(const key_type&)
+ assert(n == 1);
+ assert((m == M{{4, 4}}));
+}
- M expected = {{"alpha", 1}, {"beta", 2}, {"eta", 4}, {"gamma", 5}};
- assert(m == expected);
+template <class KeyContainer, class ValueContainer>
+void test_transparent_comparator() {
+ using M = std::flat_map<std::string, int, TransparentComparator, KeyContainer, ValueContainer>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.erase(Transparent<std::string>{"abc"})), typename M::size_type);
+
+ auto n = m.erase(Transparent<std::string>{"epsilon"});
+ assert(n == 1);
+
+ M expected = {{"alpha", 1}, {"beta", 2}, {"eta", 4}, {"gamma", 5}};
+ assert(m == expected);
+
+ auto n2 = m.erase(Transparent<std::string>{"aaa"});
+ assert(n2 == 0);
+ assert(m == expected);
+}
+
+int main(int, char**) {
+ test_simple<std::vector<int>, std::vector<double>>();
+ test_simple<std::deque<int>, std::vector<double>>();
+ test_simple<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test_simple<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
+ test_transparent_comparator<std::vector<std::string>, std::vector<int>>();
+ test_transparent_comparator<std::deque<std::string>, std::vector<int>>();
+ test_transparent_comparator<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test_transparent_comparator<std::vector<std::string, min_allocator<std::string>>,
+ std::vector<int, min_allocator<int>>>();
- auto n2 = m.erase(Transparent<std::string>{"aaa"});
- assert(n2 == 0);
- assert(m == expected);
- }
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.erase(StartsWith('b'))), M::size_type);
- M::size_type n = m.erase(StartsWith('e'));
- assert(n == 2);
- assert((m == M{{"alpha", 1}, {"beta", 2}, {"gamma", 5}}));
- n = m.erase(StartsWith('d'));
- assert(n == 0);
- assert((m == M{{"alpha", 1}, {"beta", 2}, {"gamma", 5}}));
- }
-#endif
- {
- using M = std::flat_map<int, int, std::less<>>;
- M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
- ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
- auto n = m.erase(3); // erase(K&&) [with K=int]
- assert(n == 1);
- assert((m == M{{1, 1}, {2, 2}, {4, 4}}));
- M::key_type lvalue = 2;
- n = m.erase(lvalue); // erase(K&&) [with K=int&]
- assert(n == 1);
- assert((m == M{{1, 1}, {4, 4}}));
- const M::key_type const_lvalue = 1;
- n = m.erase(const_lvalue); // erase(const key_type&)
- assert(n == 1);
- assert((m == M{{4, 4}}));
- }
- {
- using M = std::flat_map<int, int, std::less<>, std::deque<int, min_allocator<int>>, std::deque<int>>;
- M m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
- ASSERT_SAME_TYPE(decltype(m.erase(9)), M::size_type);
- auto n = m.erase(3); // erase(K&&) [with K=int]
- assert(n == 1);
- assert((m == M{{1, 1}, {2, 2}, {4, 4}}));
- M::key_type lvalue = 2;
- n = m.erase(lvalue); // erase(K&&) [with K=int&]
- assert(n == 1);
- assert((m == M{{1, 1}, {4, 4}}));
- const M::key_type const_lvalue = 1;
- n = m.erase(const_lvalue); // erase(const key_type&)
- assert(n == 1);
- assert((m == M{{4, 4}}));
- }
{
// P2077's HeterogeneousKey example
using M = std::flat_map<int, int, std::less<>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
index 8a3d37c170b503..aa70a211c2098b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
@@ -14,11 +14,15 @@
#include <algorithm>
#include <concepts>
+#include <deque>
#include <flat_map>
#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
template <class T>
concept CanExtract = requires(T&& t) { std::forward<T>(t).extract(); };
@@ -28,19 +32,27 @@ static_assert(!CanExtract<std::flat_map<int, int>&>);
static_assert(!CanExtract<std::flat_map<int, int> const&>);
static_assert(!CanExtract<std::flat_map<int, int> const&&>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using M = std::flat_map<int, int, std::less<int>, KeyContainer, ValueContainer>;
+ M m = M({1, 2, 3}, {4, 5, 6});
+
+ std::same_as<typename M::containers> auto containers = std::move(m).extract();
+
+ auto expected_keys = {1, 2, 3};
+ auto expected_values = {4, 5, 6};
+ assert(std::ranges::equal(containers.keys, expected_keys));
+ assert(std::ranges::equal(containers.values, expected_values));
+ LIBCPP_ASSERT(m.empty());
+ LIBCPP_ASSERT(m.keys().size() == 0);
+ LIBCPP_ASSERT(m.values().size() == 0);
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, int>;
- M m = M({1, 2, 3}, {4, 5, 6});
- std::same_as<M::containers> auto containers = std::move(m).extract();
- auto expected_keys = {1, 2, 3};
- auto expected_values = {4, 5, 6};
- assert(std::ranges::equal(containers.keys, expected_keys));
- assert(std::ranges::equal(containers.values, expected_values));
- LIBCPP_ASSERT(m.empty());
- LIBCPP_ASSERT(m.keys().size() == 0);
- LIBCPP_ASSERT(m.values().size() == 0);
- }
+ test<std::vector<int>, std::vector<int>>();
+ test<std::deque<int>, std::vector<int>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<int>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
{
// extracted object maintains invariant if one of underlying container does not clear after move
using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
index 4ed8bba7731d56..7e667c4e4877bf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp
@@ -13,19 +13,22 @@
// pair<iterator, bool> insert(const value_type& v);
#include <flat_map>
+#include <deque>
#include <cassert>
#include <functional>
-#include <deque>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "../helpers.h"
#include "min_allocator.h"
-template <class Container>
-void do_insert_cv_test() {
- using M = Container;
- using R = std::pair<typename M::iterator, bool>;
- using VT = typename M::value_type;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using R = std::pair<typename M::iterator, bool>;
+ using VT = typename M::value_type;
M m;
const VT v1(2, 2.5);
@@ -62,16 +65,11 @@ void do_insert_cv_test() {
}
int main(int, char**) {
- do_insert_cv_test<std::flat_map<int, double> >();
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- do_insert_cv_test<M>();
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
{
auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
using FlatMap = std::decay_t<decltype(m)>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
index 55e12c724ed293..32be3ab8a95b3d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp
@@ -17,62 +17,43 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using V = std::pair<const int, double>;
+
+ M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert({
+ {4, 1},
+ {4, 1.5},
+ {4, 2},
+ {1, 1},
+ {1, 1.5},
+ {1, 2},
+ {2, 1},
+ {2, 1.5},
+ {2, 2},
+ });
+ assert(m.size() == 4);
+ assert(std::distance(m.begin(), m.end()) == 4);
+ assert(*m.begin() == V(1, 1));
+ assert(*std::next(m.begin()) == V(2, 1));
+ assert(*std::next(m.begin(), 2) == V(3, 1));
+ assert(*std::next(m.begin(), 3) == V(4, 1));
+}
+
int main(int, char**) {
- {
- using V = std::pair<const int, double>;
- std::flat_map<int, double> m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
- m.insert({
- {4, 1},
- {4, 1.5},
- {4, 2},
- {1, 1},
- {1, 1.5},
- {1, 2},
- {2, 1},
- {2, 1.5},
- {2, 2},
- });
- assert(m.size() == 4);
- assert(std::distance(m.begin(), m.end()) == 4);
- assert(*m.begin() == V(1, 1));
- assert(*std::next(m.begin()) == V(2, 1));
- assert(*std::next(m.begin(), 2) == V(3, 1));
- assert(*std::next(m.begin(), 3) == V(4, 1));
- }
- {
- using V = std::pair<const int, double>;
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
- m.insert({
- {4, 1},
- {4, 1.5},
- {4, 2},
- {1, 1},
- {1, 1.5},
- {1, 2},
- {2, 1},
- {2, 1.5},
- {2, 2},
- {2, 1},
- {2, 1.5},
- {2, 2},
- });
- assert(m.size() == 4);
- assert(std::distance(m.begin(), m.end()) == 4);
- assert(*m.begin() == V(1, 1));
- assert(*std::next(m.begin()) == V(2, 1));
- assert(*std::next(m.begin(), 2) == V(3, 1));
- assert(*std::next(m.begin(), 3) == V(4, 1));
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto insert_func = [](auto& m, const auto& newValues) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
index a0095b831193b6..4bbe0628317dcb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp
@@ -17,15 +17,18 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "../helpers.h"
#include "min_allocator.h"
-template <class Container>
-void do_insert_iter_cv_test() {
- using M = Container;
- using R = typename M::iterator;
- using VT = typename M::value_type;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using R = typename M::iterator;
+ using VT = typename M::value_type;
M m;
const VT v1(2, 2.5);
@@ -58,16 +61,10 @@ void do_insert_iter_cv_test() {
}
int main(int, char**) {
- do_insert_iter_cv_test<std::flat_map<int, double> >();
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- do_insert_iter_cv_test<M>();
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
index d30703c3d6d76d..8455b19475fe43 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp
@@ -18,6 +18,7 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
@@ -35,8 +36,11 @@ static_assert(CanInsert<Map, cpp17_input_iterator<Pair*>, cpp17_input_iterator<P
static_assert(!CanInsert<Map, int, int>);
static_assert(!CanInsert<Map, cpp20_input_iterator<Pair*>, cpp20_input_iterator<Pair*>>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
using P = std::pair<int, double>;
+ using M = std::flat_map<int, double, std::less<int>, KeyContainer, ValueContainer>;
+
P ar1[] = {
P(2, 1),
P(2, 1.5),
@@ -59,36 +63,23 @@ int main(int, char**) {
P(0, 1.5),
P(0, 2),
};
- {
- using M = std::flat_map<int, double>;
- M m;
- m.insert(cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
- assert(m.size() == 3);
- M expected{{1, 1}, {2, 1}, {3, 1}};
- assert(m == expected);
- m.insert(cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
- assert(m.size() == 5);
- M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
- assert(m == expected2);
- }
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- M m;
- m.insert(cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
- assert(m.size() == 3);
- M expected{{1, 1}, {2, 1}, {3, 1}};
- assert(m == expected);
- m.insert(cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
- assert(m.size() == 5);
- M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
- assert(m == expected2);
- }
+ M m;
+ m.insert(cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+
+ m.insert(cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+}
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto insert_func = [](auto& m, const auto& newValues) { m.insert(newValues.begin(), newValues.end()); };
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
index b782685c5de8bf..034941b55eb80b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp
@@ -15,6 +15,7 @@
#include <cassert>
#include <deque>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "../helpers.h"
@@ -50,50 +51,28 @@ void do_insert_iter_rv_test() {
assert(r->first == 3);
assert(r->second == 3);
}
-int main(int, char**) {
- do_insert_iter_rv_test<std::flat_map<int, MoveOnly>, std::pair<int, MoveOnly>>();
- do_insert_iter_rv_test<std::flat_map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
-
- {
- using M =
- std::flat_map<int,
- MoveOnly,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<MoveOnly, min_allocator<MoveOnly>>>;
- using P = std::pair<int, MoveOnly>;
- using CP = std::pair<const int, MoveOnly>;
- do_insert_iter_rv_test<M, P>();
- do_insert_iter_rv_test<M, CP>();
- }
- {
- using M = std::flat_map<int, MoveOnly>;
- using R = typename M::iterator;
- M m;
- R r = m.insert(m.end(), {2, MoveOnly(2)});
- assert(r == m.begin());
- assert(m.size() == 1);
- assert(r->first == 2);
- assert(r->second == 2);
- r = m.insert(m.end(), {1, MoveOnly(1)});
- assert(r == m.begin());
- assert(m.size() == 2);
- assert(r->first == 1);
- assert(r->second == 1);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using P = std::pair<Key, Value>;
+ using CP = std::pair<const Key, Value>;
- r = m.insert(m.end(), {3, MoveOnly(3)});
- assert(r == std::ranges::prev(m.end()));
- assert(m.size() == 3);
- assert(r->first == 3);
- assert(r->second == 3);
+ do_insert_iter_rv_test<M, P>();
+ do_insert_iter_rv_test<M, CP>();
+}
- r = m.insert(m.end(), {3, MoveOnly(3)});
- assert(r == std::ranges::prev(m.end()));
- assert(m.size() == 3);
- assert(r->first == 3);
- assert(r->second == 3);
- }
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::vector<int>, std::vector<MoveOnly>>();
+ test<std::deque<int>, std::deque<double>>();
+ test<std::deque<int>, std::deque<MoveOnly>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<MoveOnly>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<MoveOnly, min_allocator<MoveOnly>>>();
{
auto insert_func = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
index 5a929f3b306799..5c173f45f85b46 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
@@ -14,6 +14,7 @@
#include <cassert>
#include <deque>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -76,10 +77,13 @@ static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V
static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>>, int&&, Value>);
static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>>, int&&, Value>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test_cv_key() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
{ // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
- using M = std::flat_map<int, Moveable>;
- using R = std::pair<M::iterator, bool>;
+ using R = std::pair<typename M::iterator, bool>;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
@@ -119,42 +123,14 @@ int main(int, char**) {
assert(r4.first->first == 117); // key
assert(r4.first->second.get() == -1); // value
}
- { // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
- using M = std::flat_map<Moveable, Moveable>;
- using R = std::pair<M::iterator, bool>;
- M m;
- for (int i = 0; i < 20; i += 2)
- m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
- assert(m.size() == 10);
- Moveable mvkey1(2, 2.0);
- Moveable mv1(4, 4.0);
- std::same_as<R> decltype(auto) r1 = m.insert_or_assign(std::move(mvkey1), std::move(mv1));
- assert(m.size() == 10);
- assert(!r1.second); // was not inserted
- assert(!mvkey1.moved()); // was not moved from
- assert(mv1.moved()); // was moved from
- assert(r1.first->first == mvkey1); // key
- assert(r1.first->second.get() == 4); // value
-
- Moveable mvkey2(3, 3.0);
- Moveable mv2(5, 5.0);
- std::same_as<R> decltype(auto) r2 = m.try_emplace(std::move(mvkey2), std::move(mv2));
- assert(m.size() == 11);
- assert(r2.second); // was inserted
- assert(mv2.moved()); // was moved from
- assert(mvkey2.moved()); // was moved from
- assert(r2.first->first.get() == 3); // key
- assert(r2.first->second.get() == 5); // value
- }
{ // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
- using M = std::flat_map<int, Moveable>;
M m;
using R = M::iterator;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
assert(m.size() == 10);
- M::const_iterator it = m.find(2);
+ typename M::const_iterator it = m.find(2);
Moveable mv1(3, 3.0);
std::same_as<R> decltype(auto) r1 = m.insert_or_assign(it, 2, std::move(mv1));
@@ -215,14 +191,48 @@ int main(int, char**) {
assert(r8->first == 9); // key
assert(r8->second.get() == 17); // value
}
+}
+
+template <class KeyContainer, class ValueContainer>
+void test_rv_key() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+
+ { // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+ using R = std::pair<typename M::iterator, bool>;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
+ assert(m.size() == 10);
+
+ Moveable mvkey1(2, 2.0);
+ Moveable mv1(4, 4.0);
+ std::same_as<R> decltype(auto) r1 = m.insert_or_assign(std::move(mvkey1), std::move(mv1));
+ assert(m.size() == 10);
+ assert(!r1.second); // was not inserted
+ assert(!mvkey1.moved()); // was not moved from
+ assert(mv1.moved()); // was moved from
+ assert(r1.first->first == mvkey1); // key
+ assert(r1.first->second.get() == 4); // value
+
+ Moveable mvkey2(3, 3.0);
+ Moveable mv2(5, 5.0);
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(std::move(mvkey2), std::move(mv2));
+ assert(m.size() == 11);
+ assert(r2.second); // was inserted
+ assert(mv2.moved()); // was moved from
+ assert(mvkey2.moved()); // was moved from
+ assert(r2.first->first.get() == 3); // key
+ assert(r2.first->second.get() == 5); // value
+ }
{ // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
- using M = std::flat_map<Moveable, Moveable>;
using R = M::iterator;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
assert(m.size() == 10);
- M::const_iterator it = std::next(m.cbegin());
+ typename M::const_iterator it = std::next(m.cbegin());
Moveable mvkey1(2, 2.0);
Moveable mv1(4, 4.0);
@@ -299,6 +309,18 @@ int main(int, char**) {
assert(r8->first.get() == 11); // key
assert(r8->second.get() == 13); // value
}
+}
+
+int main(int, char**) {
+ test_cv_key<std::vector<int>, std::vector<Moveable>>();
+ test_cv_key<std::deque<int>, std::vector<Moveable>>();
+ test_cv_key<MinSequenceContainer<int>, MinSequenceContainer<Moveable>>();
+ test_cv_key<std::vector<int, min_allocator<int>>, std::vector<Moveable, min_allocator<Moveable>>>();
+
+ test_rv_key<std::vector<Moveable>, std::vector<Moveable>>();
+ test_rv_key<std::deque<Moveable>, std::vector<Moveable>>();
+ test_rv_key<MinSequenceContainer<Moveable>, MinSequenceContainer<Moveable>>();
+ test_rv_key<std::vector<Moveable, min_allocator<Moveable>>, std::vector<Moveable, min_allocator<Moveable>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
index 162ec57cd44ee9..26084e54b9dc38 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
@@ -14,6 +14,7 @@
#include <cassert>
#include <deque>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -95,10 +96,14 @@ static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>, Trans
ConvertibleTransparent<int>,
Value>);
-int main(int, char**) {
- { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
- using M = std::flat_map<int, Moveable, TransparentComparator>;
- using R = std::pair<M::iterator, bool>;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+ {
+ // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+ using R = std::pair<typename M::iterator, bool>;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
@@ -138,15 +143,14 @@ int main(int, char**) {
assert(r4.first->first == 117); // key
assert(r4.first->second.get() == -1); // value
}
-
- { // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
- using M = std::flat_map<int, Moveable, TransparentComparator>;
- M m;
+ {
+ // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
using R = M::iterator;
+ M m;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
assert(m.size() == 10);
- M::const_iterator it = m.find(2);
+ typename M::const_iterator it = m.find(2);
Moveable mv1(3, 3.0);
std::same_as<R> decltype(auto) r1 = m.insert_or_assign(it, ConvertibleTransparent<int>{2}, std::move(mv1));
@@ -209,6 +213,14 @@ int main(int, char**) {
assert(r8->first == 9); // key
assert(r8->second.get() == 17); // value
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<Moveable>>();
+ test<std::deque<int>, std::vector<Moveable>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<Moveable>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<Moveable, min_allocator<Moveable>>>();
+
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
index 1edddc3ace724d..a2e64431a3c255 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp
@@ -20,6 +20,7 @@
#include <ranges>
#include <vector>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "MoveOnly.h"
#include "test_macros.h"
@@ -37,10 +38,14 @@ static_assert(CanInsertRange<Map, std::ranges::subrange<std::pair<short, double>
static_assert(!CanInsertRange<Map, std::ranges::subrange<int*>>);
static_assert(!CanInsertRange<Map, std::ranges::subrange<double*>>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+
{
using P = std::pair<int, int>;
- using M = std::flat_map<int, int>;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
using It = forward_iterator<const P*>;
M m = {{10, 1}, {8, 2}, {5, 3}, {2, 4}, {1, 5}};
P ar[] = {{3, 1}, {1, 2}, {4, 3}, {1, 4}, {5, 5}, {9, 6}};
@@ -51,7 +56,7 @@ int main(int, char**) {
}
{
using P = std::pair<int, int>;
- using M = std::flat_map<int, int, std::greater<>, std::deque<int, min_allocator<int>>>;
+ using M = std::flat_map<Key, Value, std::greater<>, KeyContainer, ValueContainer>;
using It = cpp20_input_iterator<const P*>;
M m = {{8, 1}, {5, 2}, {3, 3}, {2, 4}};
P ar[] = {{3, 1}, {1, 2}, {4, 3}, {1, 4}, {5, 5}, {9, 6}};
@@ -66,24 +71,19 @@ int main(int, char**) {
bool operator()(int a, int b) const { return (a % 10) < (b % 10); }
};
using P = std::pair<int, int>;
- using M = std::flat_map<int, int, ModTen>;
+ using M = std::flat_map<Key, Value, ModTen, KeyContainer, ValueContainer>;
M m = {{21, 0}, {43, 0}, {15, 0}, {37, 0}};
P ar[] = {{33, 1}, {18, 1}, {55, 1}, {18, 1}, {42, 1}};
m.insert_range(ar);
assert((m == M{{21, 0}, {42, 1}, {43, 0}, {15, 0}, {37, 0}, {18, 1}}));
}
- {
- // The "uniquing" part uses the comparator, not operator==.
- struct ModTen {
- bool operator()(int a, int b) const { return (a % 10) < (b % 10); }
- };
- using P = std::pair<int, int>;
- using M = std::flat_map<int, int, ModTen>;
- M m = {{21, 0}, {43, 0}, {15, 0}, {37, 0}};
- P ar[] = {{33, 1}, {18, 1}, {55, 1}, {28, 1}, {42, 1}};
- m.insert_range(ar);
- LIBCPP_ASSERT((m == M{{21, 0}, {42, 1}, {43, 0}, {15, 0}, {37, 0}, {18, 1}}));
- }
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<int>>();
+ test<std::deque<int>, std::vector<int>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<int>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
{
// Items are forwarded correctly from the input range (P2767).
std::pair<MoveOnly, MoveOnly> a[] = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
index cd141d82e96fc3..9ea7a6a6366664 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp
@@ -18,6 +18,7 @@
#include <cassert>
#include <deque>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -58,22 +59,25 @@ void do_insert_rv_test() {
assert(r.first->second == 3);
}
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+
+ using P = std::pair<Key, Value>;
+ using CP = std::pair<const Key, Value>;
+
+ do_insert_rv_test<M, P>();
+ do_insert_rv_test<M, CP>();
+}
+
int main(int, char**) {
- do_insert_rv_test<std::flat_map<int, MoveOnly>, std::pair<int, MoveOnly>>();
- do_insert_rv_test<std::flat_map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
+ test<std::vector<int>, std::vector<MoveOnly>>();
+ test<std::deque<int>, std::vector<MoveOnly>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<MoveOnly>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<MoveOnly, min_allocator<MoveOnly>>>();
- {
- using M =
- std::flat_map<int,
- MoveOnly,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<MoveOnly, min_allocator<MoveOnly>>>;
- using P = std::pair<int, MoveOnly>;
- using CP = std::pair<const int, MoveOnly>;
- do_insert_rv_test<M, P>();
- do_insert_rv_test<M, CP>();
- }
{
using M = std::flat_map<int, MoveOnly>;
using R = std::pair<M::iterator, bool>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
index 1ead3d67251920..08d2caf3498791 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp
@@ -17,53 +17,41 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ using V = std::pair<const Key, Value>;
+ M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
+ m.insert(std::sorted_unique,
+ {
+ {0, 1},
+ {1, 2},
+ {2, 1},
+ {4, 1},
+ });
+ assert(m.size() == 5);
+ assert(std::distance(m.begin(), m.end()) == 5);
+ assert(*m.begin() == V(0, 1));
+ assert(*std::next(m.begin()) == V(1, 1));
+ assert(*std::next(m.begin(), 2) == V(2, 1));
+ assert(*std::next(m.begin(), 3) == V(3, 1));
+ assert(*std::next(m.begin(), 4) == V(4, 1));
+}
+
int main(int, char**) {
- {
- using V = std::pair<const int, double>;
- std::flat_map<int, double> m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
- m.insert(std::sorted_unique,
- {
- {0, 1},
- {1, 2},
- {2, 1},
- {4, 1},
- });
- assert(m.size() == 5);
- assert(std::distance(m.begin(), m.end()) == 5);
- assert(*m.begin() == V(0, 1));
- assert(*std::next(m.begin()) == V(1, 1));
- assert(*std::next(m.begin(), 2) == V(2, 1));
- assert(*std::next(m.begin(), 3) == V(3, 1));
- assert(*std::next(m.begin(), 4) == V(4, 1));
- }
- {
- using V = std::pair<const int, double>;
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- M m = {{1, 1}, {1, 1.5}, {1, 2}, {3, 1}, {3, 1.5}, {3, 2}};
- m.insert(std::sorted_unique,
- {
- {0, 1},
- {1, 2},
- {2, 1},
- {4, 1},
- });
- assert(m.size() == 5);
- assert(std::distance(m.begin(), m.end()) == 5);
- assert(*m.begin() == V(0, 1));
- assert(*std::next(m.begin()) == V(1, 1));
- assert(*std::next(m.begin(), 2) == V(2, 1));
- assert(*std::next(m.begin(), 3) == V(3, 1));
- assert(*std::next(m.begin(), 4) == V(4, 1));
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
{
auto insert_func = [](auto& m, const auto& newValues) {
using FlatMap = std::decay_t<decltype(m)>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
index ef603817d70743..18a3b571a41994 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp
@@ -18,6 +18,7 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
@@ -35,8 +36,13 @@ static_assert(CanInsert<Map, std::sorted_unique_t, cpp17_input_iterator<Pair*>,
static_assert(!CanInsert<Map, std::sorted_unique_t, int, int>);
static_assert(!CanInsert<Map, std::sorted_unique_t, cpp20_input_iterator<Pair*>, cpp20_input_iterator<Pair*>>);
-int main(int, char**) {
- using P = std::pair<int, double>;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using P = std::pair<Key, Value>;
+
P ar1[] = {
P(1, 1),
P(2, 1),
@@ -48,45 +54,27 @@ int main(int, char**) {
P(2, 2),
P(4, 1),
};
- {
- using M = std::flat_map<int, double>;
- M m;
- m.insert(std::sorted_unique,
- cpp17_input_iterator<P*>(ar1),
- cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
- assert(m.size() == 3);
- M expected{{1, 1}, {2, 1}, {3, 1}};
- assert(m == expected);
-
- m.insert(std::sorted_unique,
- cpp17_input_iterator<P*>(ar2),
- cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
- assert(m.size() == 5);
- M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
- assert(m == expected2);
- }
- {
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<double, min_allocator<double>>>;
- M m;
- m.insert(std::sorted_unique,
- cpp17_input_iterator<P*>(ar1),
- cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
- assert(m.size() == 3);
- M expected{{1, 1}, {2, 1}, {3, 1}};
- assert(m == expected);
-
- m.insert(std::sorted_unique,
- cpp17_input_iterator<P*>(ar2),
- cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
- assert(m.size() == 5);
- M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
- assert(m == expected2);
- }
+
+ M m;
+ m.insert(
+ std::sorted_unique, cpp17_input_iterator<P*>(ar1), cpp17_input_iterator<P*>(ar1 + sizeof(ar1) / sizeof(ar1[0])));
+ assert(m.size() == 3);
+ M expected{{1, 1}, {2, 1}, {3, 1}};
+ assert(m == expected);
+
+ m.insert(
+ std::sorted_unique, cpp17_input_iterator<P*>(ar2), cpp17_input_iterator<P*>(ar2 + sizeof(ar2) / sizeof(ar2[0])));
+ assert(m.size() == 5);
+ M expected2{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}};
+ assert(m == expected2);
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
{
auto insert_func = [](auto& m, const auto& newValues) {
m.insert(std::sorted_unique, newValues.begin(), newValues.end());
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
index 0b0e2327c8814e..75cabb70630f32 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp
@@ -16,10 +16,12 @@
#include <algorithm>
#include <compare>
#include <concepts>
+#include <deque>
#include <flat_map>
#include <functional>
#include <tuple>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
#include "test_iterators.h"
@@ -56,17 +58,22 @@ struct CompareCounter {
}
};
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
{
// insert(P&&)
// Unlike flat_set, here we can't use key_compare to compare value_type versus P,
// so we must eagerly convert to value_type.
- using M = std::flat_map<CompareCounter, int, std::less<>>;
- M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3, 3)); // conversion happens first
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<typename M::iterator, bool>> auto p =
+ m.insert(std::make_pair(3, 3)); // conversion happens first
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
@@ -74,11 +81,10 @@ int main(int, char**) {
}
{
// insert(const_iterator, P&&)
- using M = std::flat_map<CompareCounter, int, std::less<>>;
- M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<typename M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(it == m.begin() + 2);
@@ -86,11 +92,11 @@ int main(int, char**) {
}
{
// insert(value_type&&)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.insert(std::make_pair(3, 3)); // conversion happens last
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<typename M::iterator, bool>> auto p =
+ m.insert(std::make_pair(3, 3)); // conversion happens last
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
@@ -98,11 +104,10 @@ int main(int, char**) {
}
{
// insert(const_iterator, value_type&&)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<typename M::iterator> auto it = m.insert(m.begin(), std::make_pair(3, 3));
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(it == m.begin() + 2);
@@ -110,16 +115,24 @@ int main(int, char**) {
}
{
// emplace(Args&&...)
- using M = std::flat_map<CompareCounter, int>;
- M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- expensive_comparisons = 0;
- cheap_comparisons = 0;
- std::same_as<std::pair<M::iterator, bool>> auto p = m.emplace(std::make_pair(3, 3)); // conversion happens first
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ expensive_comparisons = 0;
+ cheap_comparisons = 0;
+ std::same_as<std::pair<typename M::iterator, bool>> auto p =
+ m.emplace(std::make_pair(3, 3)); // conversion happens first
assert(expensive_comparisons >= 2);
assert(cheap_comparisons == 0);
assert(p == std::make_pair(m.begin() + 2, true));
assert(std::ranges::equal(m, expected));
}
+}
+
+int main(int, char**) {
+ test<std::vector<CompareCounter>, std::vector<double>>();
+ test<std::deque<CompareCounter>, std::vector<double>>();
+ test<MinSequenceContainer<CompareCounter>, MinSequenceContainer<double>>();
+ test<std::vector<CompareCounter, min_allocator<CompareCounter>>, std::vector<double, min_allocator<double>>>();
+
{
// no ambiguity between insert(pos, P&&) and insert(first, last)
using M = std::flat_map<int, int>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
index 97b886c40ae807..2ab16c67d9e09b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
@@ -13,12 +13,15 @@
// void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
#include <algorithm>
+#include <deque>
#include <concepts>
#include <flat_map>
#include <functional>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
template <class T, class... Args>
concept CanReplace = requires(T t, Args&&... args) { t.replace(std::forward<Args>(args)...); };
@@ -29,19 +32,29 @@ static_assert(!CanReplace<Map, const std::vector<int>&, std::vector<int>>);
static_assert(!CanReplace<Map, std::vector<int>, const std::vector<int>&>);
static_assert(!CanReplace<Map, const std::vector<int>&, const std::vector<int>&>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ M m = M({1, 2, 3}, {4, 5, 6});
+ KeyContainer new_keys = {7, 8};
+ ValueContainer new_values = {9, 10};
+ auto expected_keys = new_keys;
+ auto expected_values = new_values;
+ m.replace(std::move(new_keys), std::move(new_values));
+ assert(m.size() == 2);
+ assert(std::ranges::equal(m.keys(), expected_keys));
+ assert(std::ranges::equal(m.values(), expected_values));
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, int>;
- M m = M({1, 2, 3}, {4, 5, 6});
- std::vector<int> new_keys = {7, 8};
- std::vector<int> new_values = {9, 10};
- auto expected_keys = new_keys;
- auto expected_values = new_values;
- m.replace(std::move(new_keys), std::move(new_values));
- assert(m.size() == 2);
- assert(std::ranges::equal(m.keys(), expected_keys));
- assert(std::ranges::equal(m.values(), expected_values));
- }
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
+
{
#ifndef TEST_HAS_NO_EXCEPTIONS
using KeyContainer = std::vector<int>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
index b616ec2bb0b307..4999c9f164994b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
@@ -15,7 +15,10 @@
#include <flat_map>
#include <cassert>
#include <deque>
+#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -32,99 +35,60 @@ static_assert(NoExceptAdlSwap<std::flat_map<int, int>>);
static_assert(
NoExceptAdlSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
-int main(int, char**) {
- using V = std::pair<const int, double>;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using V = std::pair<const Key, Value>;
+
{
- using M = std::flat_map<int, double>;
- {
- M m1;
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1;
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
}
{
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>;
- {
- M m1;
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1;
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- swap(m1, m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
}
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ swap(m1, m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto swap_func = [](auto& m1, auto& m2) { swap(m1, m2); };
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
index b6eedff3696fa2..667a0180865582 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
@@ -15,7 +15,10 @@
#include <flat_map>
#include <cassert>
#include <deque>
+#include <functional>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "MoveOnly.h"
#include "min_allocator.h"
#include "test_macros.h"
@@ -32,99 +35,59 @@ static_assert(NoExceptMemberSwap<std::flat_map<int, int>>);
static_assert(
NoExceptMemberSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
-int main(int, char**) {
- using V = std::pair<const int, double>;
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using V = std::pair<const Key, Value>;
+ {
+ M m1;
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
+ {
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1;
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
+ }
{
- using M = std::flat_map<int, double>;
- {
- M m1;
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1;
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2;
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
}
{
- using M =
- std::flat_map<int,
- double,
- std::less<int>,
- std::vector<int, min_allocator<int>>,
- std::vector<double, min_allocator<double>>>;
- {
- M m1;
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1;
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2;
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
- {
- V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
- V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
- M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
- M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
- M m1_save = m1;
- M m2_save = m2;
- m1.swap(m2);
- assert(m1 == m2_save);
- assert(m2 == m1_save);
- }
+ V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
+ V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
+ M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
+ M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
+ M m1_save = m1;
+ M m2_save = m2;
+ m1.swap(m2);
+ assert(m1 == m2_save);
+ assert(m2 == m1_save);
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<double>>();
+ test<std::deque<int>, std::vector<double>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
{
auto swap_func = [](auto& m1, auto& m2) { m1.swap(m2); };
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
index 90305e3e03c280..4be2fe1c4333e0 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp
@@ -24,6 +24,7 @@
#include <functional>
#include <deque>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "../helpers.h"
#include "min_allocator.h"
@@ -61,10 +62,14 @@ static_assert(CanTryEmplace<Map, Iter, Emplaceable, int, double>);
static_assert(!CanTryEmplace<Map, Iter, Emplaceable, const Emplaceable&>);
static_assert(!CanTryEmplace<Map, Iter, Emplaceable, int>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test_ck() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
{ // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
- using M = std::flat_map<int, Moveable>;
- using R = std::pair<M::iterator, bool>;
+ using R = std::pair<typename M::iterator, bool>;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
@@ -104,9 +109,39 @@ int main(int, char**) {
assert(r4.first->second.get() == -1); // value
}
+ { // iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
+ using R = typename M::iterator;
+ M m;
+ for (int i = 0; i < 20; i += 2)
+ m.try_emplace(i, Moveable(i, (double)i));
+ assert(m.size() == 10);
+ typename M::const_iterator it = m.find(2);
+
+ Moveable mv1(3, 3.0);
+ for (int i = 0; i < 20; i += 2) {
+ std::same_as<R> decltype(auto) r1 = m.try_emplace(it, i, std::move(mv1));
+ assert(m.size() == 10);
+ assert(!mv1.moved()); // was not moved from
+ assert(r1->first == i); // key
+ assert(r1->second.get() == i); // value
+ }
+
+ std::same_as<R> decltype(auto) r2 = m.try_emplace(it, 3, std::move(mv1));
+ assert(m.size() == 11);
+ assert(mv1.moved()); // was moved from
+ assert(r2->first == 3); // key
+ assert(r2->second.get() == 3); // value
+ }
+}
+
+template <class KeyContainer, class ValueContainer>
+void test_rk() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
{ // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
- using M = std::flat_map<Moveable, Moveable>;
- using R = std::pair<M::iterator, bool>;
+ using R = std::pair<typename M::iterator, bool>;
M m;
for (int i = 0; i < 20; i += 2) {
m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
@@ -132,39 +167,13 @@ int main(int, char**) {
assert(r2.first->second.get() == 4); // value
}
- { // iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
- using M = std::flat_map<int, Moveable>;
- using R = typename M::iterator;
- M m;
- for (int i = 0; i < 20; i += 2)
- m.try_emplace(i, Moveable(i, (double)i));
- assert(m.size() == 10);
- M::const_iterator it = m.find(2);
-
- Moveable mv1(3, 3.0);
- for (int i = 0; i < 20; i += 2) {
- std::same_as<R> decltype(auto) r1 = m.try_emplace(it, i, std::move(mv1));
- assert(m.size() == 10);
- assert(!mv1.moved()); // was not moved from
- assert(r1->first == i); // key
- assert(r1->second.get() == i); // value
- }
-
- std::same_as<R> decltype(auto) r2 = m.try_emplace(it, 3, std::move(mv1));
- assert(m.size() == 11);
- assert(mv1.moved()); // was moved from
- assert(r2->first == 3); // key
- assert(r2->second.get() == 3); // value
- }
-
{ // iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
- using M = std::flat_map<Moveable, Moveable>;
using R = typename M::iterator;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(Moveable(i, (double)i), Moveable(i + 1, (double)i + 1));
assert(m.size() == 10);
- M::const_iterator it = std::next(m.cbegin());
+ typename M::const_iterator it = std::next(m.cbegin());
Moveable mvkey1(2, 2.0);
Moveable mv1(4, 4.0);
@@ -182,6 +191,18 @@ int main(int, char**) {
assert(r2->first.get() == 3); // key
assert(r2->second.get() == 4); // value
}
+}
+
+int main(int, char**) {
+ test_ck<std::vector<int>, std::vector<Moveable>>();
+ test_ck<std::deque<int>, std::vector<Moveable>>();
+ test_ck<MinSequenceContainer<int>, MinSequenceContainer<Moveable>>();
+ test_ck<std::vector<int, min_allocator<int>>, std::vector<Moveable, min_allocator<Moveable>>>();
+
+ test_rk<std::vector<Moveable>, std::vector<Moveable>>();
+ test_rk<std::deque<Moveable>, std::vector<Moveable>>();
+ test_rk<MinSequenceContainer<Moveable>, MinSequenceContainer<Moveable>>();
+ test_rk<std::vector<Moveable, min_allocator<Moveable>>, std::vector<Moveable, min_allocator<Moveable>>>();
{
auto try_emplace_ck = [](auto& m, auto key_arg, auto value_arg) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
index 66c3b2013210bf..21fda437809674 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp
@@ -19,7 +19,9 @@
#include <cassert>
#include <functional>
#include <deque>
+#include <vector>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "../helpers.h"
#include "min_allocator.h"
@@ -62,10 +64,14 @@ static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, NonConvert
static_assert(!CanTryEmplace<NonTransparentMap, TransparentMapConstIter, NonConvertibleTransparent<int>, Emplaceable>);
static_assert(!CanTryEmplace<TransparentMap, TransparentMapConstIter, ConvertibleTransparent<int>, int>);
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+
{ // pair<iterator, bool> try_emplace(K&& k, Args&&... args);
- using M = std::flat_map<int, Moveable, TransparentComparator>;
- using R = std::pair<M::iterator, bool>;
+ using R = std::pair<typename M::iterator, bool>;
M m;
for (int i = 0; i < 20; i += 2)
m.emplace(i, Moveable(i, (double)i));
@@ -106,13 +112,12 @@ int main(int, char**) {
}
{ // iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
- using M = std::flat_map<int, Moveable, TransparentComparator>;
using R = typename M::iterator;
M m;
for (int i = 0; i < 20; i += 2)
m.try_emplace(i, Moveable(i, (double)i));
assert(m.size() == 10);
- M::const_iterator it = m.find(2);
+ typename M::const_iterator it = m.find(2);
Moveable mv1(3, 3.0);
for (int i = 0; i < 20; i += 2) {
@@ -129,6 +134,13 @@ int main(int, char**) {
assert(r2->first == 3); // key
assert(r2->second.get() == 3); // value
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<Moveable>>();
+ test<std::deque<int>, std::vector<Moveable>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<Moveable>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<Moveable, min_allocator<Moveable>>>();
{
bool transparent_used = false;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
index f5a4da1dfd639b..84d8f8344aaa67 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp
@@ -22,43 +22,36 @@
#include <deque>
#include <string>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ const M m = {{4, 'a'}, {2, 'b'}, {3, 'c'}};
+ std::same_as<const KeyContainer&> decltype(auto) keys = m.keys();
+ std::same_as<const ValueContainer&> decltype(auto) values = m.values();
+
+ // noexcept
+ static_assert(noexcept(m.keys()));
+ static_assert(noexcept(m.values()));
+
+ auto expected_keys = {2, 3, 4};
+ auto expected_values = {'b', 'c', 'a'};
+ assert(std::ranges::equal(keys, expected_keys));
+ assert(std::ranges::equal(values, expected_values));
+}
int main(int, char**) {
- {
- using M = std::flat_map<int, char>;
- const M m = {{4, 'a'}, {2, 'b'}, {3, 'c'}};
- std::same_as<const std::vector<int>&> decltype(auto) keys = m.keys();
- std::same_as<const std::vector<char>&> decltype(auto) values = m.values();
-
- // noexcept
- static_assert(noexcept(m.keys()));
- static_assert(noexcept(m.values()));
-
- auto expected_keys = {2, 3, 4};
- auto expected_values = {'b', 'c', 'a'};
- assert(std::ranges::equal(keys, expected_keys));
- assert(std::ranges::equal(values, expected_values));
- }
-
- {
- using KeyContainer = std::deque<double>;
- using ValueContainer = std::vector<int, test_allocator<int>>;
- using M = std::flat_map<double, int, std::less<>, KeyContainer, ValueContainer>;
- const M m = {{1.0, 1}, {4.0, 4}, {2.0, 2}};
- std::same_as<const KeyContainer&> decltype(auto) keys = m.keys();
- std::same_as<const ValueContainer&> decltype(auto) values = m.values();
-
- // noexcept
- static_assert(noexcept(m.keys()));
- static_assert(noexcept(m.values()));
-
- auto expected_keys = {1.0, 2.0, 4.0};
- auto expected_values = {1, 2, 4};
- assert(std::ranges::equal(keys, expected_keys));
- assert(std::ranges::equal(values, expected_values));
- }
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
index 6569625bf8b7fb..208d6138fa6836 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp
@@ -18,13 +18,17 @@
#include <functional>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
{
- using M = std::flat_map<int, const char*>;
- M m = {{1, ""}, {2, ""}, {4, ""}, {5, ""}, {8, ""}};
+ using M = std::flat_map<Key, Value, std::less<>, KeyContainer, ValueContainer>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}, {8, 8}};
assert(!m.contains(0));
assert(m.contains(1));
assert(m.contains(2));
@@ -39,7 +43,7 @@ int main(int, char**) {
assert(!m.contains(1));
}
{
- using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ using M = std::flat_map<Key, Value, std::greater<int>, KeyContainer, ValueContainer>;
M m = {{1, 0}, {2, 0}, {4, 0}, {5, 0}, {8, 0}};
assert(!m.contains(0));
assert(m.contains(1));
@@ -54,23 +58,13 @@ int main(int, char**) {
m.clear();
assert(!m.contains(1));
}
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, int>;
- M m = {{true, 1}, {false, 2}};
- assert(m.contains(true));
- assert(m.contains(false));
- m = {{true, 3}};
- assert(m.contains(true));
- assert(!m.contains(false));
- m = {{false, 4}};
- assert(!std::as_const(m).contains(true));
- assert(std::as_const(m).contains(false));
- m.clear();
- assert(!m.contains(true));
- assert(!m.contains(false));
- }
-#endif
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<int>>();
+ test<std::deque<int>, std::vector<int>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<int>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
index c4fd8643a66d3e..0493538ab6dadc 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp
@@ -16,9 +16,12 @@
#include <flat_map>
#include <string>
#include <utility>
+#include <deque>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -30,21 +33,31 @@ static_assert(CanContains<const TransparentMap>);
static_assert(!CanContains<NonTransparentMap>);
static_assert(!CanContains<const NonTransparentMap>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.contains(Transparent<std::string>{"abc"})), bool);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(Transparent<std::string>{"b"})), bool);
+ assert(m.contains(Transparent<std::string>{"alpha"}) == true);
+ assert(m.contains(Transparent<std::string>{"beta"}) == true);
+ assert(m.contains(Transparent<std::string>{"epsilon"}) == true);
+ assert(m.contains(Transparent<std::string>{"eta"}) == true);
+ assert(m.contains(Transparent<std::string>{"gamma"}) == true);
+ assert(m.contains(Transparent<std::string>{"al"}) == false);
+ assert(m.contains(Transparent<std::string>{""}) == false);
+ assert(m.contains(Transparent<std::string>{"g"}) == false);
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.contains(Transparent<std::string>{"abc"})), bool);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(Transparent<std::string>{"b"})), bool);
- assert(m.contains(Transparent<std::string>{"alpha"}) == true);
- assert(m.contains(Transparent<std::string>{"beta"}) == true);
- assert(m.contains(Transparent<std::string>{"epsilon"}) == true);
- assert(m.contains(Transparent<std::string>{"eta"}) == true);
- assert(m.contains(Transparent<std::string>{"gamma"}) == true);
- assert(m.contains(Transparent<std::string>{"al"}) == false);
- assert(m.contains(Transparent<std::string>{""}) == false);
- assert(m.contains(Transparent<std::string>{"g"}) == false);
- }
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
+
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -54,21 +67,5 @@ int main(int, char**) {
assert(b);
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.contains(StartsWith('b'))), bool);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(StartsWith('b'))), bool);
- assert(m.contains("beta") == true);
- assert(m.contains("delta") == false);
- assert(m.contains("zeta") == false);
- assert(m.contains(StartsWith('b')) == true);
- assert(m.contains(StartsWith('d')) == false);
- assert(m.contains(StartsWith('e')) == true);
- assert(m.contains(StartsWith('z')) == false);
- }
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
index e5a143046f5f58..db675854d5e98b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp
@@ -18,13 +18,18 @@
#include <functional>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+
{
- using M = std::flat_map<int, const char*>;
- M m = {{1, ""}, {2, ""}, {4, ""}, {5, ""}, {8, ""}};
+ using M = std::flat_map<Key, Value, std::less<>, KeyContainer, ValueContainer>;
+ M m = {{1, 1}, {2, 2}, {4, 4}, {5, 5}, {8, 8}};
ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
assert(m.count(0) == 0);
assert(m.count(1) == 1);
@@ -38,7 +43,7 @@ int main(int, char**) {
assert(std::as_const(m).count(9) == 0);
}
{
- using M = std::flat_map<int, int, std::greater<int>, std::deque<int, min_allocator<int>>>;
+ using M = std::flat_map<Key, Value, std::greater<int>, KeyContainer, ValueContainer>;
M m = {{1, 0}, {2, 0}, {4, 0}, {5, 0}, {8, 0}};
ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
assert(m.count(0) == 0);
@@ -52,24 +57,13 @@ int main(int, char**) {
assert(std::as_const(m).count(8) == 1);
assert(std::as_const(m).count(9) == 0);
}
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, int>;
- M m = {{true, 1}, {false, 2}};
- ASSERT_SAME_TYPE(decltype(m.count(0)), size_t);
- assert(m.count(true) == 1);
- assert(m.count(false) == 1);
- m = {{true, 3}};
- assert(m.count(true) == 1);
- assert(m.count(false) == 0);
- m = {{false, 4}};
- assert(std::as_const(m).count(true) == 0);
- assert(std::as_const(m).count(false) == 1);
- m.clear();
- assert(m.count(true) == 0);
- assert(m.count(false) == 0);
- }
-#endif
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<int>>();
+ test<std::deque<int>, std::vector<int>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<int>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<int, min_allocator<int>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
index b7f7aa0290fac6..9c04aa0a549456 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
@@ -17,8 +17,10 @@
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -30,21 +32,31 @@ static_assert(CanCount<const TransparentMap>);
static_assert(!CanCount<NonTransparentMap>);
static_assert(!CanCount<const NonTransparentMap>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ ASSERT_SAME_TYPE(decltype(m.count(Transparent<std::string>{"abc"})), typename M::size_type);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).count(Transparent<std::string>{"b"})), typename M::size_type);
+ assert(m.count(Transparent<std::string>{"alpha"}) == 1);
+ assert(m.count(Transparent<std::string>{"beta"}) == 1);
+ assert(m.count(Transparent<std::string>{"epsilon"}) == 1);
+ assert(m.count(Transparent<std::string>{"eta"}) == 1);
+ assert(m.count(Transparent<std::string>{"gamma"}) == 1);
+ assert(m.count(Transparent<std::string>{"al"}) == 0);
+ assert(m.count(Transparent<std::string>{""}) == 0);
+ assert(m.count(Transparent<std::string>{"g"}) == 0);
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.count(Transparent<std::string>{"abc"})), M::size_type);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).count(Transparent<std::string>{"b"})), M::size_type);
- assert(m.count(Transparent<std::string>{"alpha"}) == 1);
- assert(m.count(Transparent<std::string>{"beta"}) == 1);
- assert(m.count(Transparent<std::string>{"epsilon"}) == 1);
- assert(m.count(Transparent<std::string>{"eta"}) == 1);
- assert(m.count(Transparent<std::string>{"gamma"}) == 1);
- assert(m.count(Transparent<std::string>{"al"}) == 0);
- assert(m.count(Transparent<std::string>{""}) == 0);
- assert(m.count(Transparent<std::string>{"g"}) == 0);
- }
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
+
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -54,21 +66,6 @@ int main(int, char**) {
assert(n == 1);
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.count(StartsWith('b'))), M::size_type);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).count(StartsWith('b'))), M::size_type);
- assert(m.count("beta") == 1);
- assert(m.count("delta") == 0);
- assert(m.count("zeta") == 0);
- assert(m.count(StartsWith('b')) == 1);
- assert(m.count(StartsWith('d')) == 0);
- assert(m.count(StartsWith('e')) == 2);
- assert(m.count(StartsWith('z')) == 0);
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
index e72f50c7302a45..8fa73d2a2eb51d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp
@@ -19,14 +19,18 @@
#include <functional>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
{
- using M = std::flat_map<int, char>;
- using R = std::pair<M::iterator, M::iterator>;
- using CR = std::pair<M::const_iterator, M::const_iterator>;
+ using M = std::flat_map<Key, Value, std::less<>, KeyContainer, ValueContainer>;
+ using R = std::pair<typename M::iterator, typename M::iterator>;
+ using CR = std::pair<typename M::const_iterator, typename M::const_iterator>;
M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
@@ -42,15 +46,11 @@ int main(int, char**) {
assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin() + 4, m.cbegin() + 5));
assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin() + 5, m.cbegin() + 5));
}
+
{
- using M =
- std::flat_map<int,
- char,
- std::greater<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<char, min_allocator<char>>>;
- using R = std::pair<M::iterator, M::iterator>;
- using CR = std::pair<M::const_iterator, M::const_iterator>;
+ using M = std::flat_map<Key, Value, std::greater<int>, KeyContainer, ValueContainer>;
+ using R = std::pair<typename M::iterator, typename M::iterator>;
+ using CR = std::pair<typename M::const_iterator, typename M::const_iterator>;
M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
@@ -66,27 +66,13 @@ int main(int, char**) {
assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin() + 1));
assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin()));
}
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- using R = std::pair<M::iterator, M::iterator>;
- using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{true, false}, {false, true}};
- ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR);
- assert(m.equal_range(true) == std::pair(m.begin() + 1, m.end()));
- assert(m.equal_range(false) == std::pair(m.begin(), m.begin() + 1));
- m = {{true, true}};
- assert(m.equal_range(true) == std::pair(m.begin(), m.end()));
- assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
- m = {{false, false}};
- assert(std::as_const(m).equal_range(true) == std::pair(m.cend(), m.cend()));
- assert(std::as_const(m).equal_range(false) == std::pair(m.cbegin(), m.cend()));
- m.clear();
- assert(m.equal_range(true) == std::pair(m.begin(), m.begin()));
- assert(m.equal_range(false) == std::pair(m.begin(), m.begin()));
- }
-#endif
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
index 4abbefa9dd10d4..35c6380c829750 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
@@ -18,8 +18,10 @@
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -31,48 +33,58 @@ static_assert(CanEqualRange<const TransparentMap>);
static_assert(!CanEqualRange<NonTransparentMap>);
static_assert(!CanEqualRange<const NonTransparentMap>);
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- using R = std::pair<M::iterator, M::iterator>;
- using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- const auto& cm = m;
- ASSERT_SAME_TYPE(decltype(m.equal_range(Transparent<std::string>{"abc"})), R);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(Transparent<std::string>{"b"})), CR);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
- auto test_found = [&](auto&& m, const std::string& expected_key, int expected_value) {
- auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
- assert(last - first == 1);
- auto [key, value] = *first;
- assert(key == expected_key);
- assert(value == expected_value);
- };
+ using R = std::pair<typename M::iterator, typename M::iterator>;
+ using CR = std::pair<typename M::const_iterator, typename M::const_iterator>;
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.equal_range(Transparent<std::string>{"abc"})), R);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(Transparent<std::string>{"b"})), CR);
- auto test_not_found = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
- assert(first == last);
- assert(first - m.begin() == expected_offset);
- };
+ auto test_found = [&](auto&& m, const std::string& expected_key, int expected_value) {
+ auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ assert(last - first == 1);
+ auto [key, value] = *first;
+ assert(key == expected_key);
+ assert(value == expected_value);
+ };
- test_found(m, "alpha", 1);
- test_found(m, "beta", 2);
- test_found(m, "epsilon", 3);
- test_found(m, "eta", 4);
- test_found(m, "gamma", 5);
- test_found(cm, "alpha", 1);
- test_found(cm, "beta", 2);
- test_found(cm, "epsilon", 3);
- test_found(cm, "eta", 4);
- test_found(cm, "gamma", 5);
+ auto test_not_found = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ assert(first == last);
+ assert(first - m.begin() == expected_offset);
+ };
+
+ test_found(m, "alpha", 1);
+ test_found(m, "beta", 2);
+ test_found(m, "epsilon", 3);
+ test_found(m, "eta", 4);
+ test_found(m, "gamma", 5);
+ test_found(cm, "alpha", 1);
+ test_found(cm, "beta", 2);
+ test_found(cm, "epsilon", 3);
+ test_found(cm, "eta", 4);
+ test_found(cm, "gamma", 5);
+
+ test_not_found(m, "charlie", 2);
+ test_not_found(m, "aaa", 0);
+ test_not_found(m, "zzz", 5);
+ test_not_found(cm, "charlie", 2);
+ test_not_found(cm, "aaa", 0);
+ test_not_found(cm, "zzz", 5);
+}
+
+int main(int, char**) {
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
- test_not_found(m, "charlie", 2);
- test_not_found(m, "aaa", 0);
- test_not_found(m, "zzz", 5);
- test_not_found(cm, "charlie", 2);
- test_not_found(cm, "aaa", 0);
- test_not_found(cm, "zzz", 5);
- }
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -82,24 +94,6 @@ int main(int, char**) {
assert(p.first != p.second);
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- using R = std::pair<M::iterator, M::iterator>;
- using CR = std::pair<M::const_iterator, M::const_iterator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.equal_range(StartsWith('b'))), R);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(StartsWith('b'))), CR);
- auto begin = m.begin();
- assert(m.equal_range("beta") == std::pair(begin + 1, begin + 2));
- assert(m.equal_range("delta") == std::pair(begin + 2, begin + 2));
- assert(m.equal_range("zeta") == std::pair(begin + 5, begin + 5));
- assert(m.equal_range(StartsWith('b')) == std::pair(begin + 1, begin + 2));
- assert(m.equal_range(StartsWith('d')) == std::pair(begin + 2, begin + 2));
- assert(m.equal_range(StartsWith('e')) == std::pair(begin + 2, begin + 4));
- assert(m.equal_range(StartsWith('z')) == std::pair(begin + 5, begin + 5));
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
index 83362d379f47d7..9fae407c7d8f7c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp
@@ -20,65 +20,36 @@
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
+ ASSERT_SAME_TYPE(decltype(m.find(0)), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), typename M::const_iterator);
+ assert(m.find(0) == m.end());
+ assert(m.find(1) == m.begin());
+ assert(m.find(2) == m.begin() + 1);
+ assert(m.find(3) == m.end());
+ assert(m.find(4) == m.begin() + 2);
+ assert(m.find(5) == m.begin() + 3);
+ assert(m.find(6) == m.end());
+ assert(m.find(7) == m.end());
+ assert(std::as_const(m).find(8) == m.begin() + 4);
+ assert(std::as_const(m).find(9) == m.end());
+}
+
int main(int, char**) {
- {
- using M = std::flat_map<int, char>;
- M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
- ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
- assert(m.find(0) == m.end());
- assert(m.find(1) == m.begin());
- assert(m.find(2) == m.begin() + 1);
- assert(m.find(3) == m.end());
- assert(m.find(4) == m.begin() + 2);
- assert(m.find(5) == m.begin() + 3);
- assert(m.find(6) == m.end());
- assert(m.find(7) == m.end());
- assert(std::as_const(m).find(8) == m.begin() + 4);
- assert(std::as_const(m).find(9) == m.end());
- }
-// std::string is not a sequence container
-#if 0
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
- {
- using M = std::flat_map<int, char, std::greater<int>, std::deque<int, min_allocator<int>>, std::string>;
- M m = {{1,'a'}, {2,'b'}, {4,'d'}, {5,'e'}, {8,'h'}};
- ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
- assert(m.find(0) == m.end());
- assert(m.find(1) == m.begin() + 4);
- assert(m.find(2) == m.begin() + 3);
- assert(m.find(3) == m.end());
- assert(m.find(4) == m.begin() + 2);
- assert(m.find(5) == m.begin() + 1);
- assert(m.find(6) == m.end());
- assert(m.find(7) == m.end());
- assert(std::as_const(m).find(8) == m.begin());
- assert(std::as_const(m).find(9) == m.end());
- }
-#endif
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- M m = {{true, false}, {false, true}};
- ASSERT_SAME_TYPE(decltype(m.find(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), M::const_iterator);
- assert(m.find(true) == m.begin() + 1);
- assert(m.find(false) == m.begin());
- m = {{true, true}};
- assert(m.find(true) == m.begin());
- assert(m.find(false) == m.end());
- m = {{false, false}};
- assert(std::as_const(m).find(true) == m.end());
- assert(std::as_const(m).find(false) == m.begin());
- m.clear();
- assert(m.find(true) == m.end());
- assert(m.find(false) == m.end());
- }
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
index 49b5e0a9ef16ed..4834dee04af9d2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
@@ -14,12 +14,15 @@
// template<class K> const_iterator find(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -31,36 +34,46 @@ static_assert(CanFind<const TransparentMap>);
static_assert(!CanFind<NonTransparentMap>);
static_assert(!CanFind<const NonTransparentMap>);
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- const auto& cm = m;
- ASSERT_SAME_TYPE(decltype(m.find(Transparent<std::string>{"abc"})), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(Transparent<std::string>{"b"})), M::const_iterator);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
- auto test_find = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.find(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
- };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.find(Transparent<std::string>{"abc"})), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).find(Transparent<std::string>{"b"})), typename M::const_iterator);
+
+ auto test_find = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.find(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
+
+ test_find(m, "alpha", 0);
+ test_find(m, "beta", 1);
+ test_find(m, "epsilon", 2);
+ test_find(m, "eta", 3);
+ test_find(m, "gamma", 4);
+ test_find(m, "charlie", 5);
+ test_find(m, "aaa", 5);
+ test_find(m, "zzz", 5);
+ test_find(cm, "alpha", 0);
+ test_find(cm, "beta", 1);
+ test_find(cm, "epsilon", 2);
+ test_find(cm, "eta", 3);
+ test_find(cm, "gamma", 4);
+ test_find(cm, "charlie", 5);
+ test_find(cm, "aaa", 5);
+ test_find(cm, "zzz", 5);
+}
+
+int main(int, char**) {
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
- test_find(m, "alpha", 0);
- test_find(m, "beta", 1);
- test_find(m, "epsilon", 2);
- test_find(m, "eta", 3);
- test_find(m, "gamma", 4);
- test_find(m, "charlie", 5);
- test_find(m, "aaa", 5);
- test_find(m, "zzz", 5);
- test_find(cm, "alpha", 0);
- test_find(cm, "beta", 1);
- test_find(cm, "epsilon", 2);
- test_find(cm, "eta", 3);
- test_find(cm, "gamma", 4);
- test_find(cm, "charlie", 5);
- test_find(cm, "aaa", 5);
- test_find(cm, "zzz", 5);
- }
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -70,23 +83,6 @@ int main(int, char**) {
assert(it != m.end());
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.find(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).find(StartsWith('b'))), M::const_iterator);
- assert(m.find("beta") == m.begin() + 1);
- assert(m.find("delta") == m.end());
- assert(m.find("zeta") == m.end());
- assert(m.find(StartsWith('b')) == m.begin() + 1);
- assert(m.find(StartsWith('d')) == m.end());
- auto it = m.find(StartsWith('e'));
- assert(m.begin() + 2 <= it && it <= m.begin() + 3); // either is acceptable
- LIBCPP_ASSERT(it == m.begin() + 2); // return the earliest match
- assert(m.find(StartsWith('z')) == m.end());
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
index 2a62ce34603d4c..b5491f3b226746 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp
@@ -19,15 +19,19 @@
#include <functional>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
{
- using M = std::flat_map<int, char>;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
- ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), typename M::const_iterator);
assert(m.lower_bound(0) == m.begin());
assert(m.lower_bound(1) == m.begin());
assert(m.lower_bound(2) == m.begin() + 1);
@@ -40,15 +44,10 @@ int main(int, char**) {
assert(std::as_const(m).lower_bound(9) == m.end());
}
{
- using M =
- std::flat_map<int,
- char,
- std::greater<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<char, min_allocator<char>>>;
- M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
- ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
+ using M = std::flat_map<Key, Value, std::greater<Key>, KeyContainer, ValueContainer>;
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), typename M::const_iterator);
assert(m.lower_bound(0) == m.end());
assert(m.lower_bound(1) == m.begin() + 4);
assert(m.lower_bound(2) == m.begin() + 3);
@@ -60,25 +59,13 @@ int main(int, char**) {
assert(std::as_const(m).lower_bound(8) == m.begin());
assert(std::as_const(m).lower_bound(9) == m.begin());
}
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- M m = {{true, false}, {false, true}};
- ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), M::const_iterator);
- assert(m.lower_bound(true) == m.begin() + 1);
- assert(m.lower_bound(false) == m.begin());
- m = {{true, true}};
- assert(m.lower_bound(true) == m.begin());
- assert(m.lower_bound(false) == m.begin());
- m = {{false, false}};
- assert(std::as_const(m).lower_bound(true) == m.end());
- assert(std::as_const(m).lower_bound(false) == m.begin());
- m.clear();
- assert(m.lower_bound(true) == m.end());
- assert(m.lower_bound(false) == m.end());
- }
-#endif
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
index b6dc4332c0f130..142783c7134ff5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
@@ -18,8 +18,10 @@
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -31,43 +33,53 @@ static_assert(CanLowerBound<const TransparentMap>);
static_assert(!CanLowerBound<NonTransparentMap>);
static_assert(!CanLowerBound<const NonTransparentMap>);
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- const auto& cm = m;
- ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), M::const_iterator);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
- auto test_lower_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.lower_bound(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
- };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), typename M::const_iterator);
- test_lower_bound(m, "abc", 0);
- test_lower_bound(m, "alpha", 0);
- test_lower_bound(m, "beta", 1);
- test_lower_bound(m, "bets", 2);
- test_lower_bound(m, "charlie", 2);
- test_lower_bound(m, "echo", 2);
- test_lower_bound(m, "epsilon", 2);
- test_lower_bound(m, "eta", 3);
- test_lower_bound(m, "gamma", 4);
- test_lower_bound(m, "golf", 5);
- test_lower_bound(m, "zzz", 5);
+ auto test_lower_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.lower_bound(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
+
+ test_lower_bound(m, "abc", 0);
+ test_lower_bound(m, "alpha", 0);
+ test_lower_bound(m, "beta", 1);
+ test_lower_bound(m, "bets", 2);
+ test_lower_bound(m, "charlie", 2);
+ test_lower_bound(m, "echo", 2);
+ test_lower_bound(m, "epsilon", 2);
+ test_lower_bound(m, "eta", 3);
+ test_lower_bound(m, "gamma", 4);
+ test_lower_bound(m, "golf", 5);
+ test_lower_bound(m, "zzz", 5);
+
+ test_lower_bound(cm, "abc", 0);
+ test_lower_bound(cm, "alpha", 0);
+ test_lower_bound(cm, "beta", 1);
+ test_lower_bound(cm, "bets", 2);
+ test_lower_bound(cm, "charlie", 2);
+ test_lower_bound(cm, "echo", 2);
+ test_lower_bound(cm, "epsilon", 2);
+ test_lower_bound(cm, "eta", 3);
+ test_lower_bound(cm, "gamma", 4);
+ test_lower_bound(cm, "golf", 5);
+ test_lower_bound(cm, "zzz", 5);
+}
+
+int main(int, char**) {
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
- test_lower_bound(cm, "abc", 0);
- test_lower_bound(cm, "alpha", 0);
- test_lower_bound(cm, "beta", 1);
- test_lower_bound(cm, "bets", 2);
- test_lower_bound(cm, "charlie", 2);
- test_lower_bound(cm, "echo", 2);
- test_lower_bound(cm, "epsilon", 2);
- test_lower_bound(cm, "eta", 3);
- test_lower_bound(cm, "gamma", 4);
- test_lower_bound(cm, "golf", 5);
- test_lower_bound(cm, "zzz", 5);
- }
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -77,21 +89,6 @@ int main(int, char**) {
assert(it != m.end());
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.lower_bound(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(StartsWith('b'))), M::const_iterator);
- assert(m.lower_bound("beta") == m.begin() + 1);
- assert(m.lower_bound("delta") == m.begin() + 2);
- assert(m.lower_bound("zeta") == m.begin() + 5);
- assert(m.lower_bound(StartsWith('b')) == m.begin() + 1);
- assert(m.lower_bound(StartsWith('d')) == m.begin() + 2);
- assert(m.lower_bound(StartsWith('e')) == m.begin() + 2);
- assert(m.lower_bound(StartsWith('z')) == m.begin() + 5);
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
index 29a0a63179caa1..775e53286d6295 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp
@@ -19,15 +19,19 @@
#include <functional>
#include <utility>
+#include "MinSequenceContainer.h"
#include "test_macros.h"
#include "min_allocator.h"
-int main(int, char**) {
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
{
- using M = std::flat_map<int, char>;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
- ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), typename M::const_iterator);
assert(m.upper_bound(0) == m.begin());
assert(m.upper_bound(1) == m.begin() + 1);
assert(m.upper_bound(2) == m.begin() + 2);
@@ -39,16 +43,12 @@ int main(int, char**) {
assert(std::as_const(m).upper_bound(8) == m.end());
assert(std::as_const(m).upper_bound(9) == m.end());
}
+
{
- using M =
- std::flat_map<int,
- char,
- std::greater<int>,
- std::deque<int, min_allocator<int>>,
- std::deque<char, min_allocator<char>>>;
- M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
- ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
+ using M = std::flat_map<Key, Value, std::greater<Key>, KeyContainer, ValueContainer>;
+ M m = {{1, 'a'}, {2, 'b'}, {4, 'd'}, {5, 'e'}, {8, 'h'}};
+ ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), typename M::const_iterator);
assert(m.upper_bound(0) == m.end());
assert(m.upper_bound(1) == m.end());
assert(m.upper_bound(2) == m.begin() + 4);
@@ -60,25 +60,13 @@ int main(int, char**) {
assert(std::as_const(m).upper_bound(8) == m.begin() + 1);
assert(std::as_const(m).upper_bound(9) == m.begin());
}
-#if 0
- // vector<bool> is not supported
- {
- using M = std::flat_map<bool, bool>;
- M m = {{true, false}, {false, true}};
- ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), M::const_iterator);
- assert(m.upper_bound(true) == m.end());
- assert(m.upper_bound(false) == m.begin() + 1);
- m = {{true, true}};
- assert(m.upper_bound(true) == m.end());
- assert(m.upper_bound(false) == m.begin());
- m = {{false, false}};
- assert(std::as_const(m).upper_bound(true) == m.end());
- assert(std::as_const(m).upper_bound(false) == m.end());
- m.clear();
- assert(m.upper_bound(true) == m.end());
- assert(m.upper_bound(false) == m.end());
- }
-#endif
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
index a07f13fcdd32a9..ccfc745eefd5c8 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
@@ -18,8 +18,10 @@
#include <string>
#include <utility>
+#include "MinSequenceContainer.h"
#include "../helpers.h"
#include "test_macros.h"
+#include "min_allocator.h"
// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.
template <class M>
@@ -31,43 +33,52 @@ static_assert(CanUpperBound<const TransparentMap>);
static_assert(!CanUpperBound<NonTransparentMap>);
static_assert(!CanUpperBound<const NonTransparentMap>);
-int main(int, char**) {
- {
- using M = std::flat_map<std::string, int, TransparentComparator>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- const auto& cm = m;
- ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), M::const_iterator);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, TransparentComparator, KeyContainer, ValueContainer>;
- auto test_upper_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.upper_bound(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
- };
+ M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
+ const auto& cm = m;
+ ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), typename M::iterator);
+ ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), typename M::const_iterator);
- test_upper_bound(m, "abc", 0);
- test_upper_bound(m, "alpha", 1);
- test_upper_bound(m, "beta", 2);
- test_upper_bound(m, "bets", 2);
- test_upper_bound(m, "charlie", 2);
- test_upper_bound(m, "echo", 2);
- test_upper_bound(m, "epsilon", 3);
- test_upper_bound(m, "eta", 4);
- test_upper_bound(m, "gamma", 5);
- test_upper_bound(m, "golf", 5);
- test_upper_bound(m, "zzz", 5);
+ auto test_upper_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
+ auto iter = m.upper_bound(Transparent<std::string>{expected_key});
+ assert(iter - m.begin() == expected_offset);
+ };
- test_upper_bound(cm, "abc", 0);
- test_upper_bound(cm, "alpha", 1);
- test_upper_bound(cm, "beta", 2);
- test_upper_bound(cm, "bets", 2);
- test_upper_bound(cm, "charlie", 2);
- test_upper_bound(cm, "echo", 2);
- test_upper_bound(cm, "epsilon", 3);
- test_upper_bound(cm, "eta", 4);
- test_upper_bound(cm, "gamma", 5);
- test_upper_bound(cm, "golf", 5);
- test_upper_bound(cm, "zzz", 5);
- }
+ test_upper_bound(m, "abc", 0);
+ test_upper_bound(m, "alpha", 1);
+ test_upper_bound(m, "beta", 2);
+ test_upper_bound(m, "bets", 2);
+ test_upper_bound(m, "charlie", 2);
+ test_upper_bound(m, "echo", 2);
+ test_upper_bound(m, "epsilon", 3);
+ test_upper_bound(m, "eta", 4);
+ test_upper_bound(m, "gamma", 5);
+ test_upper_bound(m, "golf", 5);
+ test_upper_bound(m, "zzz", 5);
+
+ test_upper_bound(cm, "abc", 0);
+ test_upper_bound(cm, "alpha", 1);
+ test_upper_bound(cm, "beta", 2);
+ test_upper_bound(cm, "bets", 2);
+ test_upper_bound(cm, "charlie", 2);
+ test_upper_bound(cm, "echo", 2);
+ test_upper_bound(cm, "epsilon", 3);
+ test_upper_bound(cm, "eta", 4);
+ test_upper_bound(cm, "gamma", 5);
+ test_upper_bound(cm, "golf", 5);
+ test_upper_bound(cm, "zzz", 5);
+}
+
+int main(int, char**) {
+ test<std::vector<std::string>, std::vector<int>>();
+ test<std::deque<std::string>, std::vector<int>>();
+ test<MinSequenceContainer<std::string>, MinSequenceContainer<int>>();
+ test<std::vector<std::string, min_allocator<std::string>>, std::vector<int, min_allocator<int>>>();
{
bool transparent_used = false;
TransparentComparator c(transparent_used);
@@ -77,21 +88,6 @@ int main(int, char**) {
assert(it != m.end());
assert(transparent_used);
}
-#if 0
-// do we really want to support this weird comparator that gives different answer for Key and Kp?
- {
- using M = std::flat_map<std::string, int, StartsWith::Less>;
- M m = {{"alpha", 1}, {"beta", 2}, {"epsilon", 3}, {"eta", 4}, {"gamma", 5}};
- ASSERT_SAME_TYPE(decltype(m.upper_bound(StartsWith('b'))), M::iterator);
- ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(StartsWith('b'))), M::const_iterator);
- assert(m.upper_bound("beta") == m.begin() + 2);
- assert(m.upper_bound("delta") == m.begin() + 2);
- assert(m.upper_bound("zeta") == m.begin() + 5);
- assert(m.upper_bound(StartsWith('b')) == m.begin() + 2);
- assert(m.upper_bound(StartsWith('d')) == m.begin() + 2);
- assert(m.upper_bound(StartsWith('e')) == m.begin() + 4);
- assert(m.upper_bound(StartsWith('z')) == m.begin() + 5);
- }
-#endif
+
return 0;
}
diff --git a/libcxx/test/support/MinSequenceContainer.h b/libcxx/test/support/MinSequenceContainer.h
index 4d26b301fd4efe..d0e29ae40c400d 100644
--- a/libcxx/test/support/MinSequenceContainer.h
+++ b/libcxx/test/support/MinSequenceContainer.h
@@ -17,8 +17,8 @@
template <class T, class Iterator = random_access_iterator<T*>, class ConstIterator = random_access_iterator<const T*>>
struct MinSequenceContainer {
using value_type = T;
- using difference_type = short;
- using size_type = unsigned short;
+ using difference_type = int;
+ using size_type = unsigned int;
using iterator = Iterator;
using const_iterator = ConstIterator;
@@ -38,21 +38,29 @@ struct MinSequenceContainer {
template <class It>
iterator insert(const_iterator p, It first, It last) {
- auto it = data_.insert(p - cbegin() + data_.begin(), first, last);
- return it - data_.begin() + begin();
+ return from_vector_iterator(data_.insert(to_vector_iterator(p), first, last));
}
- iterator insert(const_iterator p, int value) {
- auto it = data_.insert(p - cbegin() + data_.begin(), value);
- return it - data_.begin() + begin();
+ iterator insert(const_iterator p, T value) {
+ return from_vector_iterator(data_.insert(to_vector_iterator(p), std::move(value)));
}
iterator erase(const_iterator first, const_iterator last) {
- auto it = data_.erase(first - cbegin() + data_.begin(), last - cbegin() + data_.begin());
- return it - data_.begin() + begin();
+ return from_vector_iterator(data_.erase(to_vector_iterator(first), to_vector_iterator(last)));
+ }
+
+ iterator erase(const_iterator iter) { return from_vector_iterator(data_.erase(to_vector_iterator(iter))); }
+
+ template <class... Args>
+ iterator emplace(const_iterator pos, Args&&... args) {
+ return from_vector_iterator(data_.emplace(to_vector_iterator(pos), std::forward<Args>(args)...));
}
private:
+ std::vector<T>::const_iterator to_vector_iterator(const_iterator cit) const { return cit - cbegin() + data_.begin(); }
+
+ iterator from_vector_iterator(std::vector<T>::iterator it) { return it - data_.begin() + begin(); }
+
std::vector<T> data_;
};
>From ea7603bf192922f6a93de393ebfd7d10d53566fe Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 5 Oct 2024 12:48:14 +0100
Subject: [PATCH 23/40] constexpr
---
libcxx/include/__utility/exception_guard.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/libcxx/include/__utility/exception_guard.h b/libcxx/include/__utility/exception_guard.h
index 3136ebc76c659c..8df58b946fea75 100644
--- a/libcxx/include/__utility/exception_guard.h
+++ b/libcxx/include/__utility/exception_guard.h
@@ -138,7 +138,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exce
}
template <class _Rollback>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard_exceptions<_Rollback> __make_scoped_guard(_Rollback __rollback) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __exception_guard_exceptions<_Rollback> __make_scoped_guard(_Rollback __rollback) {
return __exception_guard_exceptions<_Rollback>(std::move(__rollback));
}
>From b381bd79645e83a8a3ec689967efd33b6063dd47 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 13 Oct 2024 13:51:05 +0100
Subject: [PATCH 24/40] rebase
---
libcxx/include/CMakeLists.txt | 1 -
libcxx/include/__flat_map/container_traits.h | 46 -------------------
libcxx/include/__flat_map/flat_map.h | 2 +-
libcxx/include/deque | 1 -
libcxx/include/flat_map | 1 -
libcxx/include/module.modulemap | 2 +-
.../flat.map/flat.map.cons/move.pass.cpp | 10 ++--
7 files changed, 7 insertions(+), 56 deletions(-)
delete mode 100644 libcxx/include/__flat_map/container_traits.h
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index f73b39174ef4c2..c59a63e69facf0 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -358,7 +358,6 @@ set(files
__filesystem/recursive_directory_iterator.h
__filesystem/space_info.h
__filesystem/u8path.h
- __flat_map/container_traits.h
__flat_map/flat_map.h
__flat_map/sorted_unique.h
__format/buffer.h
diff --git a/libcxx/include/__flat_map/container_traits.h b/libcxx/include/__flat_map/container_traits.h
deleted file mode 100644
index 703c7ef430f5a9..00000000000000
--- a/libcxx/include/__flat_map/container_traits.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// -*- 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_MAP_CONTAINER_TRAITS_H
-#define _LIBCPP___FLAT_MAP_CONTAINER_TRAITS_H
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-# pragma GCC system_header
-#endif
-
-#if _LIBCPP_STD_VER >= 23
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-inline constexpr bool __is_stl_container = false;
-
-template <class _Tp>
-struct __container_traits {
- static constexpr bool __emplacement_has_strong_exception_safety_guarantee = false;
-};
-
-template <class _Tp>
- requires __is_stl_container<_Tp>
-struct __container_traits<_Tp> {
- // http://eel.is/c++draft/container.reqmts
- // 66 Unless otherwise specified (see [associative.reqmts.except], [unord.req.except], [deque.modifiers],
- // [inplace.vector.modifiers], and [vector.modifiers]) all container types defined in this Clause meet the following
- // additional requirements:
- // - (66.1) If an exception is thrown by an insert() or emplace() function while inserting a single element, that
- // function has no effects.
- static constexpr bool __emplacement_has_strong_exception_safety_guarantee = true;
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER >= 23
-
-#endif // _LIBCPP___FLAT_MAP_CONTAINER_TRAITS_H
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 12d6240ac8c06a..661e7d689fdbbe 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -23,7 +23,6 @@
#include <__concepts/convertible_to.h>
#include <__concepts/swappable.h>
#include <__config>
-#include <__flat_map/container_traits.h>
#include <__flat_map/sorted_unique.h>
#include <__functional/invoke.h>
#include <__functional/is_transparent.h>
@@ -43,6 +42,7 @@
#include <__ranges/subrange.h>
#include <__ranges/zip_view.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>
diff --git a/libcxx/include/deque b/libcxx/include/deque
index 4e06bcb9c0bdfd..11219d1a99244e 100644
--- a/libcxx/include/deque
+++ b/libcxx/include/deque
@@ -194,7 +194,6 @@ template <class T, class Allocator, class Predicate>
#include <__assert>
#include <__config>
#include <__debug_utils/sanitizers.h>
-#include <__flat_map/container_traits.h>
#include <__format/enable_insertable.h>
#include <__fwd/deque.h>
#include <__iterator/distance.h>
diff --git a/libcxx/include/flat_map b/libcxx/include/flat_map
index 5f88119b5b1089..15d79dd1ddca34 100644
--- a/libcxx/include/flat_map
+++ b/libcxx/include/flat_map
@@ -39,7 +39,6 @@ namespace std {
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
-#include <__flat_map/container_traits.h>
#include <__flat_map/flat_map.h>
#include <__flat_map/sorted_unique.h>
#include <version>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 75cec4678a0544..73847e37f7c786 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1226,7 +1226,7 @@ module std [system] {
module flat_map { header "__flat_map/flat_map.h" }
module sorted_unique { header "__flat_map/sorted_unique.h" }
- head "flat_map"
+ header "flat_map"
export *
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
index b739644abd8039..57d900188e0259 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
@@ -39,8 +39,8 @@ int main(int, char**) {
assert(mo.empty());
assert(mo.key_comp() == C(5));
- assert(mo.keys().get_allocator() == A(test_alloc_base::moved_value));
- assert(mo.values().get_allocator() == A(test_alloc_base::moved_value));
+ assert(mo.keys().get_allocator().get_id() == test_alloc_base::moved_value);
+ assert(mo.values().get_allocator().get_id() == test_alloc_base::moved_value);
}
{
using C = test_less<int>;
@@ -76,9 +76,9 @@ int main(int, char**) {
{
// moved-from object maintains invariant if one of underlying container does not clear after move
using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
- M m1 = M({1,2,3},{1,2,3});
- M m2 = std::move(m1);
- assert(m2.size()==3);
+ M m1 = M({1, 2, 3}, {1, 2, 3});
+ M m2 = std::move(m1);
+ assert(m2.size() == 3);
assert(m1.keys().size() == m1.values().size());
LIBCPP_ASSERT(m1.empty());
LIBCPP_ASSERT(m1.keys().size() == 0);
>From 8d157bf0b2a3daa99289e1da6e288ef680d17eee Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 13 Oct 2024 14:15:54 +0100
Subject: [PATCH 25/40] address more comments
---
libcxx/include/__flat_map/flat_map.h | 12 ++++++++----
libcxx/include/__utility/exception_guard.h | 3 ++-
2 files changed, 10 insertions(+), 5 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 661e7d689fdbbe..48e462af897849 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -142,8 +142,12 @@ class flat_map {
friend flat_map;
public:
- using iterator_concept = random_access_iterator_tag;
- using iterator_category = input_iterator_tag;
+ using iterator_concept = random_access_iterator_tag;
+ // `flat_map::iterator` only satisfy "Cpp17InputIterator" named requirements, because
+ // its `reference` is not a reference type.
+ // However, to avoid surprising runtime behaviour when it is used with the
+ // Cpp17 algorithms or operations, iterator_category is set to random_access_iterator_tag.
+ using iterator_category = random_access_iterator_tag;
using value_type = flat_map::value_type;
using difference_type = flat_map::difference_type;
@@ -482,7 +486,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI flat_map& operator=(flat_map&& __other) noexcept(
is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_MappedContainer> &&
is_nothrow_move_assignable_v<_Compare>) {
- auto __clear_other_guard = std::__make_scoped_guard([&]() noexcept { __other.clear() /* noexcept */; });
+ auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; });
auto __clear_self_guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
__containers_ = std::move(__other.__containers_);
__compare_ = std::move(__other.__compare_);
@@ -660,7 +664,7 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI containers extract() && {
- auto __guard = std::__make_scoped_guard([&]() noexcept { clear() /* noexcept */; });
+ auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; });
auto __ret = std::move(__containers_);
return __ret;
}
diff --git a/libcxx/include/__utility/exception_guard.h b/libcxx/include/__utility/exception_guard.h
index 8df58b946fea75..00b835d3e2a2fc 100644
--- a/libcxx/include/__utility/exception_guard.h
+++ b/libcxx/include/__utility/exception_guard.h
@@ -138,7 +138,8 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exce
}
template <class _Rollback>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __exception_guard_exceptions<_Rollback> __make_scoped_guard(_Rollback __rollback) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __exception_guard_exceptions<_Rollback>
+__make_scope_guard(_Rollback __rollback) {
return __exception_guard_exceptions<_Rollback>(std::move(__rollback));
}
>From 226edd3201bb4d81a255d1c98b347b2fe430bddb Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 13 Oct 2024 20:06:22 +0100
Subject: [PATCH 26/40] CI
---
libcxx/include/__flat_map/flat_map.h | 27 ++++++-----
.../test/libcxx/transitive_includes/cxx03.csv | 44 ++++++++++++++++++
.../test/libcxx/transitive_includes/cxx11.csv | 44 ++++++++++++++++++
.../test/libcxx/transitive_includes/cxx14.csv | 45 +++++++++++++++++++
.../test/libcxx/transitive_includes/cxx17.csv | 44 ++++++++++++++++++
.../test/libcxx/transitive_includes/cxx20.csv | 44 ++++++++++++++++++
.../test/libcxx/transitive_includes/cxx23.csv | 25 +++++++++++
.../test/libcxx/transitive_includes/cxx26.csv | 25 +++++++++++
.../flat.map/flat.map.cons/deduct.verify.cpp | 26 +++++------
.../reverse_iterator.pass.cpp | 2 +
10 files changed, 302 insertions(+), 24 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 48e462af897849..42ee8d9d318f56 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -58,6 +58,9 @@
# pragma GCC system_header
#endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
#if _LIBCPP_STD_VER >= 23
_LIBCPP_BEGIN_NAMESPACE_STD
@@ -289,7 +292,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI flat_map(
key_container_type __key_cont, mapped_container_type __mapped_cont, const key_compare& __comp = key_compare())
: __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
__sort_and_unique();
}
@@ -299,7 +302,7 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI
flat_map(const key_container_type& __key_cont, const mapped_container_type& __mapped_cont, const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
__sort_and_unique();
}
@@ -312,7 +315,7 @@ class flat_map {
const key_compare& __comp,
const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
__sort_and_unique();
}
@@ -323,10 +326,10 @@ class flat_map {
mapped_container_type __mapped_cont,
const key_compare& __comp = key_compare())
: __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
- __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ __is_sorted_and_unique(__containers_.keys), "Either the key container is not sorted or it contains duplicates");
}
template <class _Allocator>
@@ -337,10 +340,10 @@ class flat_map {
const mapped_container_type& __mapped_cont,
const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
- __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ __is_sorted_and_unique(__containers_.keys), "Either the key container is not sorted or it contains duplicates");
}
template <class _Allocator>
@@ -352,10 +355,10 @@ class flat_map {
const key_compare& __comp,
const _Allocator& __alloc)
: flat_map(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
- _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers.keys.size() == __containers.values.size(),
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
"flat_map keys and mapped containers have different size");
_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
- __is_sorted_and_unique(__containers.keys), "Either the key container is not sorted or it contains duplicates");
+ __is_sorted_and_unique(__containers_.keys), "Either the key container is not sorted or it contains duplicates");
}
_LIBCPP_HIDE_FROM_ABI explicit flat_map(const key_compare& __comp) : __containers_(), __compare_(__comp) {}
@@ -512,7 +515,7 @@ class flat_map {
}
_LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
- _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { const_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()); }
@@ -982,7 +985,7 @@ class flat_map {
ranges::stable_sort(__zv.begin() + __append_start_offset, __end, __compare_key);
} else {
_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
- __is_sorted_and_unique(__containers.keys | views::drop(__append_start_offset)),
+ __is_sorted_and_unique(__containers_.keys | views::drop(__append_start_offset)),
"Either the key container is not sorted or it contains duplicates");
}
ranges::inplace_merge(__zv.begin(), __zv.begin() + __append_start_offset, __end, __compare_key);
@@ -1344,4 +1347,6 @@ _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER >= 23
+_LIBCPP_POP_MACROS
+
#endif // _LIBCPP___FLAT_MAP_FLAT_MAP_H
diff --git a/libcxx/test/libcxx/transitive_includes/cxx03.csv b/libcxx/test/libcxx/transitive_includes/cxx03.csv
index 506b5cd02c4495..2dc84963f0891e 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx03.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx03.csv
@@ -682,6 +682,50 @@ filesystem typeinfo
filesystem utility
filesystem variant
filesystem version
+flat_map algorithm
+flat_map array
+flat_map atomic
+flat_map bit
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map cmath
+flat_map compare
+flat_map concepts
+flat_map cstdarg
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map ctime
+flat_map cwchar
+flat_map cwctype
+flat_map exception
+flat_map initializer_list
+flat_map ios
+flat_map iosfwd
+flat_map iterator
+flat_map limits
+flat_map locale
+flat_map memory
+flat_map mutex
+flat_map new
+flat_map optional
+flat_map ratio
+flat_map stdexcept
+flat_map streambuf
+flat_map string
+flat_map string_view
+flat_map system_error
+flat_map tuple
+flat_map type_traits
+flat_map typeinfo
+flat_map utility
+flat_map variant
+flat_map vector
+flat_map version
format algorithm
format array
format atomic
diff --git a/libcxx/test/libcxx/transitive_includes/cxx11.csv b/libcxx/test/libcxx/transitive_includes/cxx11.csv
index 506b5cd02c4495..2dc84963f0891e 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx11.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx11.csv
@@ -682,6 +682,50 @@ filesystem typeinfo
filesystem utility
filesystem variant
filesystem version
+flat_map algorithm
+flat_map array
+flat_map atomic
+flat_map bit
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map cmath
+flat_map compare
+flat_map concepts
+flat_map cstdarg
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map ctime
+flat_map cwchar
+flat_map cwctype
+flat_map exception
+flat_map initializer_list
+flat_map ios
+flat_map iosfwd
+flat_map iterator
+flat_map limits
+flat_map locale
+flat_map memory
+flat_map mutex
+flat_map new
+flat_map optional
+flat_map ratio
+flat_map stdexcept
+flat_map streambuf
+flat_map string
+flat_map string_view
+flat_map system_error
+flat_map tuple
+flat_map type_traits
+flat_map typeinfo
+flat_map utility
+flat_map variant
+flat_map vector
+flat_map version
format algorithm
format array
format atomic
diff --git a/libcxx/test/libcxx/transitive_includes/cxx14.csv b/libcxx/test/libcxx/transitive_includes/cxx14.csv
index 828e1d62c6ec3e..27e22975573584 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx14.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx14.csv
@@ -700,6 +700,51 @@ filesystem typeinfo
filesystem utility
filesystem variant
filesystem version
+flat_map algorithm
+flat_map array
+flat_map atomic
+flat_map bit
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map cmath
+flat_map compare
+flat_map concepts
+flat_map cstdarg
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map ctime
+flat_map cwchar
+flat_map cwctype
+flat_map exception
+flat_map execution
+flat_map initializer_list
+flat_map ios
+flat_map iosfwd
+flat_map iterator
+flat_map limits
+flat_map locale
+flat_map memory
+flat_map mutex
+flat_map new
+flat_map optional
+flat_map ratio
+flat_map stdexcept
+flat_map streambuf
+flat_map string
+flat_map string_view
+flat_map system_error
+flat_map tuple
+flat_map type_traits
+flat_map typeinfo
+flat_map utility
+flat_map variant
+flat_map vector
+flat_map version
format algorithm
format array
format atomic
diff --git a/libcxx/test/libcxx/transitive_includes/cxx17.csv b/libcxx/test/libcxx/transitive_includes/cxx17.csv
index 0bee6e9beb7af1..b17eb1f2347a86 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx17.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx17.csv
@@ -706,6 +706,50 @@ filesystem utility
filesystem variant
filesystem vector
filesystem version
+flat_map algorithm
+flat_map array
+flat_map atomic
+flat_map bit
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map cmath
+flat_map compare
+flat_map concepts
+flat_map cstdarg
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map ctime
+flat_map cwchar
+flat_map cwctype
+flat_map exception
+flat_map initializer_list
+flat_map ios
+flat_map iosfwd
+flat_map iterator
+flat_map limits
+flat_map locale
+flat_map memory
+flat_map mutex
+flat_map new
+flat_map optional
+flat_map ratio
+flat_map stdexcept
+flat_map streambuf
+flat_map string
+flat_map string_view
+flat_map system_error
+flat_map tuple
+flat_map type_traits
+flat_map typeinfo
+flat_map utility
+flat_map variant
+flat_map vector
+flat_map version
format algorithm
format array
format atomic
diff --git a/libcxx/test/libcxx/transitive_includes/cxx20.csv b/libcxx/test/libcxx/transitive_includes/cxx20.csv
index 026c26f3bd9819..9efec327889c1d 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx20.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx20.csv
@@ -694,6 +694,50 @@ filesystem utility
filesystem variant
filesystem vector
filesystem version
+flat_map algorithm
+flat_map array
+flat_map atomic
+flat_map bit
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map cmath
+flat_map compare
+flat_map concepts
+flat_map cstdarg
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map ctime
+flat_map cwchar
+flat_map cwctype
+flat_map exception
+flat_map initializer_list
+flat_map ios
+flat_map iosfwd
+flat_map iterator
+flat_map limits
+flat_map locale
+flat_map memory
+flat_map mutex
+flat_map new
+flat_map optional
+flat_map ratio
+flat_map stdexcept
+flat_map streambuf
+flat_map string
+flat_map string_view
+flat_map system_error
+flat_map tuple
+flat_map type_traits
+flat_map typeinfo
+flat_map utility
+flat_map variant
+flat_map vector
+flat_map version
format algorithm
format array
format atomic
diff --git a/libcxx/test/libcxx/transitive_includes/cxx23.csv b/libcxx/test/libcxx/transitive_includes/cxx23.csv
index c3db06f1547769..e17f732663a9b2 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx23.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx23.csv
@@ -381,6 +381,31 @@ filesystem string_view
filesystem tuple
filesystem typeinfo
filesystem version
+flat_map array
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map compare
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map cwchar
+flat_map cwctype
+flat_map initializer_list
+flat_map iosfwd
+flat_map limits
+flat_map new
+flat_map optional
+flat_map stdexcept
+flat_map string
+flat_map string_view
+flat_map tuple
+flat_map typeinfo
+flat_map vector
+flat_map version
format array
format cctype
format cerrno
diff --git a/libcxx/test/libcxx/transitive_includes/cxx26.csv b/libcxx/test/libcxx/transitive_includes/cxx26.csv
index 8d7560344ee541..c56f5cdfad0072 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx26.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx26.csv
@@ -381,6 +381,31 @@ filesystem string_view
filesystem tuple
filesystem typeinfo
filesystem version
+flat_map array
+flat_map cctype
+flat_map cerrno
+flat_map climits
+flat_map clocale
+flat_map compare
+flat_map cstddef
+flat_map cstdint
+flat_map cstdio
+flat_map cstdlib
+flat_map cstring
+flat_map cwchar
+flat_map cwctype
+flat_map initializer_list
+flat_map iosfwd
+flat_map limits
+flat_map new
+flat_map optional
+flat_map stdexcept
+flat_map string
+flat_map string_view
+flat_map tuple
+flat_map typeinfo
+flat_map vector
+flat_map version
format array
format cctype
format cerrno
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
index 8da08a968b362b..08244f01cb24e1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.verify.cpp
@@ -30,68 +30,68 @@ void test() {
// cannot deduce Key and T from just (KeyContainer), even if it's a container of pairs
std::vector<std::pair<int, int>> v;
std::flat_map s(v);
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce Key and T from just (KeyContainer, Allocator)
std::vector<int> v;
std::flat_map s(v, std::allocator<std::pair<const int, int>>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce Key and T from nothing
std::flat_map m;
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce Key and T from just (Compare)
std::flat_map m(std::less<int>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce Key and T from just (Compare, Allocator)
std::flat_map m(std::less<int>{}, std::allocator<PC>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce Key and T from just (Allocator)
std::flat_map m(std::allocator<PC>{});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot convert from some arbitrary unrelated type
NotAnAllocator a;
std::flat_map m(a);
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
std::flat_map m{{1, 1L}, {2, 2L}, {3, 3L}};
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::less<int>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::less<int>(), std::allocator<PC>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// cannot deduce that the inner braced things should be std::pair and not something else
std::flat_map m({{1, 1L}, {2, 2L}, {3, 3L}}, std::allocator<PC>());
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// since we have parens, not braces, this deliberately does not find the initializer_list constructor
std::flat_map m(P{1, 1L});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
{
// since we have parens, not braces, this deliberately does not find the initializer_list constructor
std::flat_map m(PC{1, 1L});
- // expected-error at -1{{no viable constructor or deduction guide for deduction of template arguments of 'std::flat_map'}}
+ // expected-error-re at -1{{{{no viable constructor or deduction guide for deduction of template arguments of '.*flat_map'}}}}
}
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
index e66cd81e2be928..e5531ee28f6e47 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
@@ -49,7 +49,9 @@ int main(int, char**) {
static_assert(noexcept(m.crend()));
assert(m.size() == 4);
assert(std::distance(m.rbegin(), m.rend()) == 4);
+ assert(std::distance(cm.rbegin(), cm.rend()) == 4);
assert(std::distance(m.crbegin(), m.crend()) == 4);
+ assert(std::distance(cm.crbegin(), cm.crend()) == 4);
M::reverse_iterator i; // default-construct
ASSERT_SAME_TYPE(decltype(i->first), const int&);
ASSERT_SAME_TYPE(decltype(i->second), char&);
>From 7246f6261af4373692a3c60ad98e6b8a5ba33162 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 13 Oct 2024 21:01:42 +0100
Subject: [PATCH 27/40] CI
---
libcxx/include/__flat_map/flat_map.h | 14 +-------------
libcxx/modules/std/flat_map.inc | 10 +++++-----
.../flat.map.syn/sorted_unique.pass.cpp | 12 +++---------
.../flat.map/flat.map.cons/alloc.pass.cpp | 1 -
.../flat.map/flat.map.cons/copy_alloc.pass.cpp | 2 +-
.../flat.map/flat.map.cons/move_alloc.pass.cpp | 8 ++++----
6 files changed, 14 insertions(+), 33 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 42ee8d9d318f56..70d01b2692b35e 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -90,10 +90,6 @@ class flat_map {
using key_compare = __type_identity_t<_Compare>;
using reference = pair<const key_type&, mapped_type&>;
using const_reference = pair<const key_type&, const mapped_type&>;
- // TODO : to support vector<bool> in the future, the following typedefs need to replace the above
- // using reference = pair<ranges::range_reference_t<const _KeyContainer>,
- // ranges::range_reference_t<_MappedContainer>>; using const_reference =
- // pair<ranges::range_reference_t<const _KeyContainer>, ranges::range_reference_t<const _MappedContainer>>;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator = __iterator<false>; // see [container.requirements]
@@ -985,7 +981,7 @@ class flat_map {
ranges::stable_sort(__zv.begin() + __append_start_offset, __end, __compare_key);
} else {
_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
- __is_sorted_and_unique(__containers_.keys | views::drop(__append_start_offset)),
+ __is_sorted_and_unique(__containers_.keys | ranges::views::drop(__append_start_offset)),
"Either the key container is not sorted or it contains duplicates");
}
ranges::inplace_merge(__zv.begin(), __zv.begin() + __append_start_offset, __end, __compare_key);
@@ -1074,14 +1070,6 @@ class flat_map {
template <class _Kp>
_LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) {
- // todo
- // note that we have very fragile std::prev in our library
- // for non LegacyBidirectional iterator, std::prev(it) is well formed and a no-op
- // here we cannot use std::prev because our iterator is not legacy bidirectional
- // since its reference type is not a reference
- // note that user can also attempt to use std::prev on the flat_map::iterator
- // and it would result in a no-op.
- // we should probably ban std::prev(LegacyInputIterator)
if (__hint != cbegin() && !__compare_((__hint - 1)->first, __key)) {
return false;
}
diff --git a/libcxx/modules/std/flat_map.inc b/libcxx/modules/std/flat_map.inc
index 83cd20ad618946..1ab7148acf8fc5 100644
--- a/libcxx/modules/std/flat_map.inc
+++ b/libcxx/modules/std/flat_map.inc
@@ -8,8 +8,7 @@
//===----------------------------------------------------------------------===//
export namespace std {
-#if 0
- // [flat.map], class template flat_Âmap
+ // [flat.map], class template flat_map
using std::flat_map;
using std::sorted_unique;
@@ -17,15 +16,16 @@ export namespace std {
using std::uses_allocator;
- // [flat.map.erasure], erasure for flat_Âmap
+ // [flat.map.erasure], erasure for flat_map
using std::erase_if;
- // [flat.multimap], class template flat_Âmultimap
+#if 0
+ // [flat.multimap], class template flat_multimap
using std::flat_multimap;
using std::sorted_equivalent;
using std::sorted_equivalent_t;
- // [flat.multimap.erasure], erasure for flat_Âmultimap
+ // [flat.multimap.erasure], erasure for flat_multimap
#endif
} // namespace std
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
index 59338e2da5aedc..f8bbb070b2f91d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
@@ -29,15 +29,9 @@ static_assert(std::is_trivially_default_constructible_v<std::sorted_unique_t>);
static_assert(!HasImplicitDefaultCtor<std::sorted_unique_t>);
constexpr bool test() {
- {
- [[maybe_unused]] std::sorted_unique_t s;
- }
- {
- [[maybe_unused]] std::same_as<const std::sorted_unique_t&> decltype(auto) s = (std::sorted_unique);
- }
- {
- [[maybe_unused]] std::same_as<const std::sorted_unique_t> decltype(auto) copy = std::sorted_unique;
- }
+ { [[maybe_unused]] std::sorted_unique_t s; }
+ { [[maybe_unused]] std::same_as<const std::sorted_unique_t&> decltype(auto) s = (std::sorted_unique); }
+ { [[maybe_unused]] std::same_as<const std::sorted_unique_t> decltype(auto) copy = std::sorted_unique; }
return true;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
index 53ccb388084c22..8dee25a24760ae 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -37,7 +37,6 @@ int main(int, char**) {
using M1 = std::flat_map<int, int, C, V1, V1>;
using M2 = std::flat_map<int, int, C, V1, V2>;
using M3 = std::flat_map<int, int, C, V2, V1>;
- using IL = std::initializer_list<std::pair<int, int>>;
static_assert(std::is_constructible_v<M1, const A1&>);
static_assert(!std::is_constructible_v<M1, const A2&>);
static_assert(!std::is_constructible_v<M2, const A2&>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
index 99da4b33a45c98..2b01243622da9a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
@@ -37,7 +37,7 @@ int main(int, char**) {
using M1 = std::flat_map<int, int, C, V1, V1>;
using M2 = std::flat_map<int, int, C, V1, V2>;
using M3 = std::flat_map<int, int, C, V2, V1>;
- static_assert( std::is_constructible_v<M1, const M1&, const A1&>);
+ static_assert(std::is_constructible_v<M1, const M1&, const A1&>);
static_assert(!std::is_constructible_v<M1, const M1&, const A2&>);
static_assert(!std::is_constructible_v<M2, const M2&, const A2&>);
static_assert(!std::is_constructible_v<M3, const M3&, const A2&>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index b998f7c876e107..45627850822f9a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -39,7 +39,7 @@ int main(int, char**) {
using M1 = std::flat_map<int, int, C, V1, V1>;
using M2 = std::flat_map<int, int, C, V1, V2>;
using M3 = std::flat_map<int, int, C, V2, V1>;
- static_assert( std::is_constructible_v<M1, M1&&, const A1&>);
+ static_assert(std::is_constructible_v<M1, M1&&, const A1&>);
static_assert(!std::is_constructible_v<M1, M1&&, const A2&>);
static_assert(!std::is_constructible_v<M2, M2&&, const A2&>);
static_assert(!std::is_constructible_v<M3, M3&&, const A2&>);
@@ -100,9 +100,9 @@ int main(int, char**) {
{
// moved-from object maintains invariant if one of underlying container does not clear after move
using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
- M m1 = M({1,2,3},{1,2,3});
- M m2 (std::move(m1), std::allocator<int>{});
- assert(m2.size()==3);
+ M m1 = M({1, 2, 3}, {1, 2, 3});
+ M m2(std::move(m1), std::allocator<int>{});
+ assert(m2.size() == 3);
assert(m1.keys().size() == m1.values().size());
LIBCPP_ASSERT(m1.empty());
LIBCPP_ASSERT(m1.keys().size() == 0);
>From 3d762bd6b19c16fd75ea4684528ca680e267d4fa Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Fri, 18 Oct 2024 07:01:38 +0100
Subject: [PATCH 28/40] CI
---
libcxx/include/__flat_map/flat_map.h | 33 +++++++++++++++-------------
libcxx/modules/std.cppm.in | 1 +
2 files changed, 19 insertions(+), 15 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 70d01b2692b35e..75743c7765414e 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -84,12 +84,12 @@ class flat_map {
public:
// types
- using key_type = _Key;
- using mapped_type = _Tp;
- using value_type = pair<key_type, mapped_type>;
- using key_compare = __type_identity_t<_Compare>;
- using reference = pair<const key_type&, mapped_type&>;
- using const_reference = pair<const key_type&, const mapped_type&>;
+ using key_type = _Key;
+ using mapped_type = _Tp;
+ using value_type = pair<key_type, mapped_type>;
+ using key_compare = __type_identity_t<_Compare>;
+ using reference = pair<const key_type&, mapped_type&>;
+ using const_reference = pair<const key_type&, const mapped_type&>;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator = __iterator<false>; // see [container.requirements]
@@ -252,9 +252,9 @@ class flat_map {
// state if an exception is thrown.
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
- is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
- is_nothrow_move_constructible_v<_Compare>) try
+ // gcc does not like the `throw` keyword in a conditional noexcept function
+ // split the move constructor into two
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) try
: __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
__other.clear();
} catch (...) {
@@ -262,6 +262,13 @@ class flat_map {
throw;
}
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept
+ requires is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
+ is_nothrow_move_constructible_v<_Compare>
+ : __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
+ __other.clear();
+ }
+
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map& __other, const _Allocator& __alloc)
@@ -590,8 +597,6 @@ class flat_map {
// [flat.map.modifiers], modifiers
template <class... _Args>
requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
- // todo: LWG
- // insufficiently constrained. key and values need to be move constructible
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
return __try_emplace(std::move(__pair.first), std::move(__pair.second));
@@ -809,7 +814,6 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; }
_LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__compare_); }
- // todo: can flat_map | std::views::keys be specialised?
_LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; }
_LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; }
@@ -841,7 +845,6 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
template <class _Kp>
- // todo: spec does not say about transparent for this one. LWG issue?
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const {
return find(__x) != end();
@@ -922,6 +925,7 @@ class flat_map {
};
template <class _Allocator, class _KeyCont, class _MappedCont, class... _CompArg>
+ requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI
flat_map(__ctor_uses_allocator_tag,
const _Allocator& __alloc,
@@ -935,6 +939,7 @@ class flat_map {
__compare_(std::forward<_CompArg>(__comp)...) {}
template <class _Allocator, class... _CompArg>
+ requires __allocator_ctor_constraint<_Allocator>
_LIBCPP_HIDE_FROM_ABI flat_map(__ctor_uses_allocator_empty_tag, const _Allocator& __alloc, _CompArg&&... __comp)
: __containers_{.keys = std::make_obj_using_allocator<key_container_type>(__alloc),
.values = std::make_obj_using_allocator<mapped_container_type>(__alloc)},
@@ -1183,8 +1188,6 @@ class flat_map {
struct __key_equiv {
_LIBCPP_HIDE_FROM_ABI __key_equiv(key_compare __c) : __comp_(__c) {}
_LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
- // todo
- // LWG issue ? spec uses __x.first but zip_view no longer uses pair
return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
}
key_compare __comp_;
diff --git a/libcxx/modules/std.cppm.in b/libcxx/modules/std.cppm.in
index 64ed8d4088cc01..84986cf55ebfde 100644
--- a/libcxx/modules/std.cppm.in
+++ b/libcxx/modules/std.cppm.in
@@ -64,6 +64,7 @@ module;
#include <execution>
#include <expected>
#include <filesystem>
+#include <flat_map>
#include <format>
#include <forward_list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
>From 7e95a82b4fc971e1f9871a20c2b638154224b482 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 19 Oct 2024 11:32:45 +0100
Subject: [PATCH 29/40] ci
---
libcxx/include/__flat_map/flat_map.h | 3 ++-
libcxx/modules/std.compat.cppm.in | 3 ---
libcxx/modules/std.cppm.in | 3 ---
3 files changed, 2 insertions(+), 7 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 75743c7765414e..94cc202ea7d119 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -596,7 +596,8 @@ class flat_map {
// [flat.map.modifiers], modifiers
template <class... _Args>
- requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Args...> && is_move_constructible_v<key_type> &&
+ is_move_constructible_v<mapped_type>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
return __try_emplace(std::move(__pair.first), std::move(__pair.second));
diff --git a/libcxx/modules/std.compat.cppm.in b/libcxx/modules/std.compat.cppm.in
index 797b413f68e272..fbc2c7d94cfabb 100644
--- a/libcxx/modules/std.compat.cppm.in
+++ b/libcxx/modules/std.compat.cppm.in
@@ -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_map>)
-# error "please update the header information for <flat_map> in headers_not_available in utils/libcxx/header_information.py"
-# endif // __has_include(<flat_map>)
# 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>)
diff --git a/libcxx/modules/std.cppm.in b/libcxx/modules/std.cppm.in
index 84986cf55ebfde..b4889e5a69e49b 100644
--- a/libcxx/modules/std.cppm.in
+++ b/libcxx/modules/std.cppm.in
@@ -162,9 +162,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_map>)
-# error "please update the header information for <flat_map> in headers_not_available in utils/libcxx/header_information.py"
-# endif // __has_include(<flat_map>)
# 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>)
>From 64673edd25ca16f3d4bcf0c014aee792d2c22eab Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 19 Oct 2024 15:34:26 +0100
Subject: [PATCH 30/40] review comments
---
libcxx/include/__flat_map/flat_map.h | 42 +++--
.../flat.map/flat.map.cons/move.pass.cpp | 2 +-
.../flat.map.cons/move_alloc.pass.cpp | 2 +-
.../flat.map.cons/move_assign.pass.cpp | 16 --
.../flat.map.cons/move_assign_clears.pass.cpp | 2 +-
.../move_assign_noexcept.pass.cpp | 29 ++--
.../flat.map.cons/move_exceptions.pass.cpp | 9 +-
.../flat.map.cons/move_noexcept.pass.cpp | 16 +-
.../erase_if_exceptions.pass.cpp | 13 +-
.../iterator_comparison.pass.cpp | 160 +++++++++++++-----
...rator_concept_conformance.compile.pass.cpp | 8 +
.../flat.map.modifiers/extract.pass.cpp | 5 +-
.../insert_or_assign.pass.cpp | 42 ++---
.../insert_or_assign_transparent.pass.cpp | 49 +++---
.../flat.map.modifiers/replace.pass.cpp | 3 +-
.../equal_range_transparent.pass.cpp | 8 +-
.../find_transparent.pass.cpp | 6 +-
.../lower_bound_transparent.pass.cpp | 6 +-
.../upper_bound_transparent.pass.cpp | 6 +-
.../container.adaptors/flat.map/helpers.h | 42 +++--
20 files changed, 264 insertions(+), 202 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 94cc202ea7d119..5ca201894dc4b1 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -247,26 +247,29 @@ class flat_map {
is_nothrow_default_constructible_v<_Compare>)
: __containers_(), __compare_() {}
+ _LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
+
// The copy/move constructors are not specified in the spec, which means they should be defaulted.
// However, the move constructor can potentially leave a moved-from object in an inconsistent
// state if an exception is thrown.
- _LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
-
- // gcc does not like the `throw` keyword in a conditional noexcept function
- // split the move constructor into two
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) try
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
+ is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
+ is_nothrow_move_constructible_v<_Compare>)
+# if _LIBCPP_HAS_EXCEPTIONS
+ try
+# endif // _LIBCPP_HAS_EXCEPTIONS
: __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
__other.clear();
+# if _LIBCPP_HAS_EXCEPTIONS
} catch (...) {
__other.clear();
- throw;
- }
-
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept
- requires is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
- is_nothrow_move_constructible_v<_Compare>
- : __containers_(std::move(__other.__containers_)), __compare_(std::move(__other.__compare_)) {
- __other.clear();
+ if constexpr (is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
+ is_nothrow_move_constructible_v<_Compare>) {
+ // gcc does not like the `throw` keyword in a conditional noexcept function
+ // split the move constructor into two
+ throw;
+ }
+# endif // _LIBCPP_HAS_EXCEPTIONS
}
template <class _Allocator>
@@ -280,16 +283,21 @@ class flat_map {
template <class _Allocator>
requires __allocator_ctor_constraint<_Allocator>
- _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other, const _Allocator& __alloc) try
+ _LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other, const _Allocator& __alloc)
+# if _LIBCPP_HAS_EXCEPTIONS
+ try
+# endif // _LIBCPP_HAS_EXCEPTIONS
: flat_map(__ctor_uses_allocator_tag{},
__alloc,
std::move(__other.__containers_.keys),
std::move(__other.__containers_.values),
std::move(__other.__compare_)) {
__other.clear();
+# if _LIBCPP_HAS_EXCEPTIONS
} catch (...) {
__other.clear();
throw;
+# endif // _LIBCPP_HAS_EXCEPTIONS
}
_LIBCPP_HIDE_FROM_ABI flat_map(
@@ -575,7 +583,6 @@ class flat_map {
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI mapped_type& at(const _Kp& __x) {
- static_assert(requires { find(__x); }, "flat_map::at(const K& x): find(x) needs to be well-formed");
auto __it = find(__x);
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const K&): Key does not exist");
@@ -586,7 +593,6 @@ class flat_map {
template <class _Kp>
requires __is_compare_transparent
_LIBCPP_HIDE_FROM_ABI const mapped_type& at(const _Kp& __x) const {
- static_assert(requires { find(__x); }, "flat_map::at(const K& x) const: find(x) needs to be well-formed");
auto __it = find(__x);
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
@@ -1124,8 +1130,11 @@ class flat_map {
} else {
// In this case, we know the values are just like before we attempted emplacement,
// and we also know that the keys have been emplaced successfully. Just roll back the keys.
+# if _LIBCPP_HAS_EXCEPTIONS
try {
+# endif // _LIBCPP_HAS_EXCEPTIONS
__containers_.keys.erase(__key_it);
+# if _LIBCPP_HAS_EXCEPTIONS
} catch (...) {
// Now things are funky for real. We're failing to rollback the keys.
// Just give up and clear the whole thing.
@@ -1134,6 +1143,7 @@ class flat_map {
// original value-emplacement exception propagate normally.
clear() /* noexcept */;
}
+# endif // _LIBCPP_HAS_EXCEPTIONS
}
});
auto __mapped_it = __containers_.values.emplace(__it_mapped, std::forward<_MArgs>(__mapped_args)...);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
index 57d900188e0259..955d3156064aae 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp
@@ -79,7 +79,7 @@ int main(int, char**) {
M m1 = M({1, 2, 3}, {1, 2, 3});
M m2 = std::move(m1);
assert(m2.size() == 3);
- assert(m1.keys().size() == m1.values().size());
+ check_invariant(m1);
LIBCPP_ASSERT(m1.empty());
LIBCPP_ASSERT(m1.keys().size() == 0);
LIBCPP_ASSERT(m1.values().size() == 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index 45627850822f9a..807352bc4cda1b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -103,7 +103,7 @@ int main(int, char**) {
M m1 = M({1, 2, 3}, {1, 2, 3});
M m2(std::move(m1), std::allocator<int>{});
assert(m2.size() == 3);
- assert(m1.keys().size() == m1.values().size());
+ check_invariant(m1);
LIBCPP_ASSERT(m1.empty());
LIBCPP_ASSERT(m1.keys().size() == 0);
LIBCPP_ASSERT(m1.values().size() == 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
index e29c175500671d..66af84b6bf2b7f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
@@ -89,22 +89,6 @@ int main(int, char**) {
mo.insert({"foo", 1});
assert(mo.begin()->first.get_allocator().resource() == &mr1);
}
- {
- // A moved-from flat_map maintains its class invariant in the presence of moved-from comparators.
- using C = std::function<bool(int, int)>;
- using M = std::flat_map<int, int, C>;
- M mo = M({{1, 3}, {2, 2}, {3, 1}}, std::less<int>());
- M m = M({{1, 1}, {2, 2}}, std::greater<int>());
- m = std::move(mo);
- assert(m.size() == 3);
- assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
- assert(m.key_comp()(1, 2) == true);
- assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- LIBCPP_ASSERT(m.key_comp()(1, 2) == true);
- LIBCPP_ASSERT(mo.empty());
- mo.insert({{1, 3}, {2, 2}, {3, 1}}); // insert has no preconditions
- LIBCPP_ASSERT(m == mo);
- }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
index 121bf7c15e4a4d..f28d52dd4e4633 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp
@@ -95,7 +95,7 @@ int main(int, char**) {
M m2 = M({1, 2}, {1, 2});
m2 = std::move(m1);
assert(m2.size() == 3);
- assert(m1.keys().size() == m1.values().size());
+ check_invariant(m1);
LIBCPP_ASSERT(m1.empty());
LIBCPP_ASSERT(m1.keys().size() == 0);
LIBCPP_ASSERT(m1.values().size() == 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
index b223fca99eb275..665b763e6c4f75 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp
@@ -41,6 +41,14 @@ struct MoveSensitiveComp {
bool is_moved_from_ = false;
};
+struct MoveThrowsComp {
+ MoveThrowsComp(MoveThrowsComp&&) noexcept(false);
+ MoveThrowsComp(const MoveThrowsComp&) noexcept(true);
+ MoveThrowsComp& operator=(MoveThrowsComp&&) noexcept(false);
+ MoveThrowsComp& operator=(const MoveThrowsComp&) noexcept(true);
+ bool operator()(const auto&, const auto&) const;
+};
+
int main(int, char**) {
{
using C = std::flat_map<int, int>;
@@ -82,14 +90,11 @@ int main(int, char**) {
std::vector<MoveOnly, other_allocator<MoveOnly>>>;
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
}
- /*
- why? std::function move assignment is noexcept
{
- // Test with a comparator that throws on copy-assignment.
- using C = std::flat_map<int, int, std::function<bool(int, int)>>;
+ // Test with a comparator that throws on move-assignment.
+ using C = std::flat_map<int, int, MoveThrowsComp>;
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v<C>);
}
- */
{
// Test with a container that throws on move-assignment.
using C = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::vector<int>>;
@@ -100,18 +105,6 @@ int main(int, char**) {
using C = std::flat_map<int, int, std::less<int>, std::vector<int>, std::pmr::vector<int>>;
static_assert(!std::is_nothrow_move_assignable_v<C>);
}
- /* why?
- {
- // Moving the flat_map copies the comparator (to support std::function comparators)
- using C = std::flat_map<int, int, MoveSensitiveComp>;
- LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v<C>);
- C c;
- assert(!c.key_comp().is_moved_from_);
- C d;
- d = std::move(c);
- LIBCPP_ASSERT(!c.key_comp().is_moved_from_);
- assert(!d.key_comp().is_moved_from_);
- }
- */
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
index 2cf9bdb8cb0cd9..cb7e30c2b74fae 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp
@@ -21,6 +21,7 @@
#include <utility>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
static int countdown = 0;
@@ -49,9 +50,7 @@ int main(int, char**) {
assert(x == 42);
}
// The source flat_map maintains its class invariant.
- assert(mo.keys().size() == mo.values().size());
- assert(std::is_sorted(mo.begin(), mo.end()));
- assert(std::adjacent_find(mo.keys().begin(), mo.keys().end()) == mo.keys().end());
+ check_invariant(mo);
LIBCPP_ASSERT(mo.empty());
}
{
@@ -65,9 +64,7 @@ int main(int, char**) {
assert(x == 42);
}
// The source flat_map maintains its class invariant.
- assert(mo.keys().size() == mo.values().size());
- assert(std::is_sorted(mo.begin(), mo.end()));
- assert(std::adjacent_find(mo.keys().begin(), mo.keys().end()) == mo.keys().end());
+ check_invariant(mo);
LIBCPP_ASSERT(mo.empty());
}
return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
index 3f8bb57e6658b1..d281dafbcf72dd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp
@@ -40,10 +40,10 @@ struct ThrowingMoveAllocator {
friend bool operator==(ThrowingMoveAllocator, ThrowingMoveAllocator) = default;
};
-struct ThrowingCopyComp {
- ThrowingCopyComp() = default;
- ThrowingCopyComp(const ThrowingCopyComp&) noexcept(false) {}
- ThrowingCopyComp(ThrowingCopyComp&&) noexcept {}
+struct ThrowingMoveComp {
+ ThrowingMoveComp() = default;
+ ThrowingMoveComp(const ThrowingMoveComp&) noexcept(true) {}
+ ThrowingMoveComp(ThrowingMoveComp&&) noexcept(false) {}
bool operator()(const auto&, const auto&) const { return false; }
};
@@ -92,11 +92,9 @@ int main(int, char**) {
}
#endif // _LIBCPP_VERSION
{
- // Comparator fails to be nothrow-copy-constructible
- using C = std::flat_map<int, int, ThrowingCopyComp>;
- //todo: why???
- //static_assert(!std::is_nothrow_move_constructible_v<C>);
- static_assert(std::is_nothrow_move_constructible_v<C>);
+ // Comparator fails to be nothrow-move-constructible
+ using C = std::flat_map<int, int, ThrowingMoveComp>;
+ static_assert(!std::is_nothrow_move_constructible_v<C>);
C c;
C d = std::move(c);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
index ef76e1c6192ec1..48fdec42db3fcb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
@@ -25,6 +25,7 @@
#include <utility>
#include <vector>
+#include "../helpers.h"
#include "test_macros.h"
struct Counter {
@@ -83,9 +84,7 @@ int main(int, char**) {
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
- assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ check_invariant(m);
LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
@@ -112,9 +111,7 @@ int main(int, char**) {
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
- assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ check_invariant(m);
LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
@@ -144,9 +141,7 @@ int main(int, char**) {
break;
} catch (int ex) {
assert(ex == 42);
- assert(m.keys().size() == m.values().size()); // still sized correctly
- assert(std::is_sorted(m.begin(), m.end())); // still sorted
- assert(std::adjacent_find(m.begin(), m.end()) == m.end()); // still contains no duplicates
+ check_invariant(m);
LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8));
if (g_counter.throws == 1) {
// We reached the first throw but not the second throw.
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
index 5addd191bcf7b5..d22cf7563784eb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
@@ -11,54 +11,112 @@
// <flat_map>
// flat_map iterators should be C++20 random access iterators
-// supporting `operator<=>`, even when the underlying container's
-// iterators are not.
#include <compare>
#include <concepts>
+#include <deque>
#include <flat_map>
#include <functional>
+#include <vector>
#include "MinSequenceContainer.h"
#include "test_macros.h"
+#include "min_allocator.h"
-int main(int, char**) {
-// V is not a container as <=> is required
-#if 0
- {
- using V = MinSequenceContainer<int, random_access_iterator<int*>, random_access_iterator<const int*>>;
- using M = std::flat_map<int, int, std::less<int>, V, V>;
- using VI = V::iterator;
- using VCI = V::const_iterator;
- using I = M::iterator;
- using CI = M::const_iterator;
- using RI = M::reverse_iterator;
- using CRI = M::const_reverse_iterator;
- static_assert(!std::three_way_comparable<VI>); // But, despite this...
- static_assert(!std::three_way_comparable<VCI>);
- static_assert(std::three_way_comparable<I>); // ...the wrapped iterators support <=>.
- static_assert(std::three_way_comparable<CI>);
- static_assert(std::three_way_comparable<RI>);
- static_assert(std::three_way_comparable<CRI>);
- static_assert(std::same_as<decltype(I() <=> I()), std::strong_ordering>);
- static_assert(std::same_as<decltype(I() <=> CI()), std::strong_ordering>);
- static_assert(std::same_as<decltype(CI() <=> CI()), std::strong_ordering>);
- static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
- static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
- static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
- }
-#endif
- {
- using V = MinSequenceContainer<int, int*, const int*>;
- using M = std::flat_map<int, int, std::less<int>, V, V>;
- using VI = V::iterator;
- using VCI = V::const_iterator;
- using I = M::iterator;
- using CI = M::const_iterator;
- using RI = M::reverse_iterator;
- using CRI = M::const_reverse_iterator;
- static_assert(std::three_way_comparable<VI>); // And when VI does support <=>...
- static_assert(std::three_way_comparable<VCI>);
+template <class KeyContainer, class ValueContainer>
+void test() {
+ using Key = typename KeyContainer::value_type;
+ using Value = typename ValueContainer::value_type;
+ using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
+ using KI = typename KeyContainer::iterator;
+ using KCI = typename KeyContainer::const_iterator;
+ using I = M::iterator;
+ using CI = M::const_iterator;
+ using RI = M::reverse_iterator;
+ using CRI = M::const_reverse_iterator;
+
+ static_assert(std::equality_comparable<I>);
+ static_assert(std::equality_comparable<CI>);
+ static_assert(std::equality_comparable<RI>);
+ static_assert(std::equality_comparable<CRI>);
+
+ static_assert(std::totally_ordered<I>);
+ static_assert(std::totally_ordered<CI>);
+ static_assert(std::totally_ordered<RI>);
+ static_assert(std::totally_ordered<CRI>);
+
+ M m = {{1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'}};
+
+ I i1 = m.begin();
+ I i2 = m.begin() + 1;
+
+ assert(i1 == i1);
+ assert(!(i1 != i1));
+ assert(i1 != i2);
+ assert(!(i1 == i2));
+ assert(i1 < i2);
+ assert(!(i1 < i1));
+ assert(i1 <= i1);
+ assert(i1 <= i2);
+ assert(!(i2 <= i1));
+ assert(i2 > i1);
+ assert(!(i2 > i2));
+ assert(i2 >= i1);
+ assert(i2 >= i2);
+ assert(!(i1 >= i2));
+
+ CI ci1 = m.cbegin();
+ CI ci2 = m.cbegin() + 1;
+ assert(ci1 == ci1);
+ assert(!(ci1 != ci1));
+ assert(ci1 != ci2);
+ assert(!(ci1 == ci2));
+ assert(ci1 < ci2);
+ assert(!(ci1 < ci1));
+ assert(ci1 <= ci1);
+ assert(ci1 <= ci2);
+ assert(!(ci2 <= ci1));
+ assert(ci2 > ci1);
+ assert(!(ci2 > ci2));
+ assert(ci2 >= ci1);
+ assert(ci2 >= ci2);
+ assert(!(ci1 >= ci2));
+
+ RI ri1 = m.rbegin();
+ RI ri2 = m.rbegin() + 1;
+ assert(ri1 == ri1);
+ assert(!(ri1 != ri1));
+ assert(ri1 != ri2);
+ assert(!(ri1 == ri2));
+ assert(ri1 < ri2);
+ assert(!(ri1 < ri1));
+ assert(ri1 <= ri1);
+ assert(ri1 <= ri2);
+ assert(!(ri2 <= ri1));
+ assert(ri2 > ri1);
+ assert(!(ri2 > ri2));
+ assert(ri2 >= ri1);
+ assert(ri2 >= ri2);
+ assert(!(ri1 >= ri2));
+
+ CRI cri1 = m.crbegin();
+ CRI cri2 = m.crbegin() + 1;
+ assert(cri1 == cri1);
+ assert(!(cri1 != cri1));
+ assert(cri1 != cri2);
+ assert(!(cri1 == cri2));
+ assert(cri1 < cri2);
+ assert(!(cri1 < cri1));
+ assert(cri1 <= cri1);
+ assert(cri1 <= cri2);
+ assert(!(cri2 <= cri1));
+ assert(cri2 > cri1);
+ assert(!(cri2 > cri2));
+ assert(cri2 >= cri1);
+ assert(cri2 >= cri2);
+ assert(!(cri1 >= cri2));
+
+ if constexpr (std::three_way_comparable<KI>) {
static_assert(std::three_way_comparable<I>); // ...of course the wrapped iterators still support <=>.
static_assert(std::three_way_comparable<CI>);
static_assert(std::three_way_comparable<RI>);
@@ -69,6 +127,30 @@ int main(int, char**) {
static_assert(std::same_as<decltype(RI() <=> RI()), std::strong_ordering>);
static_assert(std::same_as<decltype(RI() <=> CRI()), std::strong_ordering>);
static_assert(std::same_as<decltype(CRI() <=> CRI()), std::strong_ordering>);
+
+ assert(i1 <=> i1 == std::strong_ordering::equivalent);
+ assert(i1 <=> i2 == std::strong_ordering::less);
+ assert(i2 <=> i1 == std::strong_ordering::greater);
+
+ assert(ci1 <=> ci1 == std::strong_ordering::equivalent);
+ assert(ci1 <=> ci2 == std::strong_ordering::less);
+ assert(ci2 <=> ci1 == std::strong_ordering::greater);
+
+ assert(ri1 <=> ri1 == std::strong_ordering::equivalent);
+ assert(ri1 <=> ri2 == std::strong_ordering::less);
+ assert(ri2 <=> ri1 == std::strong_ordering::greater);
+
+ assert(cri1 <=> cri1 == std::strong_ordering::equivalent);
+ assert(cri1 <=> cri2 == std::strong_ordering::less);
+ assert(cri2 <=> cri1 == std::strong_ordering::greater);
}
+}
+
+int main(int, char**) {
+ test<std::vector<int>, std::vector<char>>();
+ test<std::deque<int>, std::vector<char>>();
+ test<MinSequenceContainer<int>, MinSequenceContainer<char>>();
+ test<std::vector<int, min_allocator<int>>, std::vector<char, min_allocator<char>>>();
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
index db7c6dd340f837..28814e2e37e3c1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp
@@ -18,6 +18,7 @@
#include <iterator>
#include <string>
#include <vector>
+#include <type_traits>
#include "MinSequenceContainer.h"
#include "test_macros.h"
@@ -64,6 +65,13 @@ void test() {
static_assert(std::indirectly_movable_storable<CI, std::pair<int, char>*>);
static_assert(std::indirectly_movable_storable<RI, std::pair<int, char>*>);
static_assert(std::indirectly_movable_storable<CRI, std::pair<int, char>*>);
+
+#ifdef _LIBCPP_VERSION
+ static_assert(std::is_same_v<typename std::iterator_traits<I>::iterator_category, std::random_access_iterator_tag>);
+ static_assert(std::is_same_v<typename std::iterator_traits<CI>::iterator_category, std::random_access_iterator_tag>);
+ static_assert(std::is_same_v<typename std::iterator_traits<RI>::iterator_category, std::random_access_iterator_tag>);
+ static_assert(std::is_same_v<typename std::iterator_traits<CRI>::iterator_category, std::random_access_iterator_tag>);
+#endif
}
void test() {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
index aa70a211c2098b..d8e4ce94efb9e9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp
@@ -43,6 +43,7 @@ void test() {
auto expected_values = {4, 5, 6};
assert(std::ranges::equal(containers.keys, expected_keys));
assert(std::ranges::equal(containers.values, expected_values));
+ check_invariant(m);
LIBCPP_ASSERT(m.empty());
LIBCPP_ASSERT(m.keys().size() == 0);
LIBCPP_ASSERT(m.values().size() == 0);
@@ -60,6 +61,7 @@ int main(int, char**) {
std::same_as<M::containers> auto containers = std::move(m).extract();
assert(containers.keys.size() == 3);
assert(containers.values.size() == 3);
+ check_invariant(m);
LIBCPP_ASSERT(m.empty());
LIBCPP_ASSERT(m.keys().size() == 0);
LIBCPP_ASSERT(m.values().size() == 0);
@@ -78,8 +80,7 @@ int main(int, char**) {
auto c = std::move(m).extract();
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we try to erase the key after value emplacement failure.
// and after erasure failure, we clear the flat_map
LIBCPP_ASSERT(m.size() == 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
index 5c173f45f85b46..398a7a1a4052e0 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp
@@ -55,27 +55,27 @@ struct AssignFrom {
AssignFrom& operator=(From);
};
-struct Value {};
-
-static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, int>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>>, const int&, Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>>, const int&, Value>);
-
-static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, int>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>>, int&&, Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>>, int&&, Value>);
-
-static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, const int&, int>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>>, const int&, Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>>, const int&, Value>);
-
-static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>>, int&&, int>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>>, int&&, Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>>, int&&, Value>);
+struct V {};
+
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>>, const int&, V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>>, const int&, int>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<V>>, const int&, V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<V>>, const int&, V>);
+
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>>, int&&, V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>>, int&&, int>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<V>>, int&&, V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<V>>, int&&, V>);
+
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>>, const int&, V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>>, const int&, int>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<V>>, const int&, V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<V>>, const int&, V>);
+
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>>, int&&, V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>>, int&&, int>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<V>>, int&&, V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<V>>, int&&, V>);
template <class KeyContainer, class ValueContainer>
void test_cv_key() {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
index 26084e54b9dc38..636c4edfe551de 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp
@@ -56,45 +56,42 @@ struct AssignFrom {
AssignFrom& operator=(From);
};
-struct Value {};
+struct V {};
-static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+static_assert(CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
ConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
NonConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, NonTransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>, NonTransparentComparator>,
NonConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
ConvertibleTransparent<int>,
int>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, ConstructFrom<Value>, TransparentComparator>,
- ConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssign<std::flat_map<int, AssignFrom<Value>, TransparentComparator>,
- ConvertibleTransparent<int>,
- Value>);
+static_assert(
+ !CanInsertOrAssign<std::flat_map<int, ConstructFrom<V>, TransparentComparator>, ConvertibleTransparent<int>, V>);
+static_assert(
+ !CanInsertOrAssign<std::flat_map<int, AssignFrom<V>, TransparentComparator>, ConvertibleTransparent<int>, V>);
-static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+static_assert(CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
ConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
NonConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, NonTransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>, NonTransparentComparator>,
NonConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<Value>, TransparentComparator>,
+ V>);
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructAndAssignFrom<V>, TransparentComparator>,
ConvertibleTransparent<int>,
int>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<Value>, TransparentComparator>,
- ConvertibleTransparent<int>,
- Value>);
-static_assert(!CanInsertOrAssignIter<std::flat_map<int, AssignFrom<Value>, TransparentComparator>,
+static_assert(!CanInsertOrAssignIter<std::flat_map<int, ConstructFrom<V>, TransparentComparator>,
ConvertibleTransparent<int>,
- Value>);
+ V>);
+static_assert(
+ !CanInsertOrAssignIter<std::flat_map<int, AssignFrom<V>, TransparentComparator>, ConvertibleTransparent<int>, V>);
template <class KeyContainer, class ValueContainer>
void test() {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
index 2ab16c67d9e09b..5ca811d7615201 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp
@@ -70,8 +70,7 @@ int main(int, char**) {
m.replace(std::move(new_keys), std::move(new_values));
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we clear the map
LIBCPP_ASSERT(m.size() == 0);
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
index 35c6380c829750..dbf74a63d98dcb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
@@ -46,16 +46,16 @@ void test() {
ASSERT_SAME_TYPE(decltype(m.equal_range(Transparent<std::string>{"abc"})), R);
ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(Transparent<std::string>{"b"})), CR);
- auto test_found = [&](auto&& m, const std::string& expected_key, int expected_value) {
- auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ auto test_found = [&](auto&& map, const std::string& expected_key, int expected_value) {
+ auto [first, last] = map.equal_range(Transparent<std::string>{expected_key});
assert(last - first == 1);
auto [key, value] = *first;
assert(key == expected_key);
assert(value == expected_value);
};
- auto test_not_found = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto [first, last] = m.equal_range(Transparent<std::string>{expected_key});
+ auto test_not_found = [&](auto&& map, const std::string& expected_key, long expected_offset) {
+ auto [first, last] = map.equal_range(Transparent<std::string>{expected_key});
assert(first == last);
assert(first - m.begin() == expected_offset);
};
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
index 4834dee04af9d2..291577a89fc8f4 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp
@@ -45,9 +45,9 @@ void test() {
ASSERT_SAME_TYPE(decltype(m.find(Transparent<std::string>{"abc"})), typename M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).find(Transparent<std::string>{"b"})), typename M::const_iterator);
- auto test_find = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.find(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
+ auto test_find = [&](auto&& map, const std::string& expected_key, long expected_offset) {
+ auto iter = map.find(Transparent<std::string>{expected_key});
+ assert(iter - map.begin() == expected_offset);
};
test_find(m, "alpha", 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
index 142783c7134ff5..7eab72c7a61ee5 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
@@ -44,9 +44,9 @@ void test() {
ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), typename M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), typename M::const_iterator);
- auto test_lower_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.lower_bound(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
+ auto test_lower_bound = [&](auto&& map, const std::string& expected_key, long expected_offset) {
+ auto iter = map.lower_bound(Transparent<std::string>{expected_key});
+ assert(iter - map.begin() == expected_offset);
};
test_lower_bound(m, "abc", 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
index ccfc745eefd5c8..ebc6f8f61acfad 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
@@ -44,9 +44,9 @@ void test() {
ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent<std::string>{"abc"})), typename M::iterator);
ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent<std::string>{"b"})), typename M::const_iterator);
- auto test_upper_bound = [&](auto&& m, const std::string& expected_key, long expected_offset) {
- auto iter = m.upper_bound(Transparent<std::string>{expected_key});
- assert(iter - m.begin() == expected_offset);
+ auto test_upper_bound = [&](auto&& map, const std::string& expected_key, long expected_offset) {
+ auto iter = map.upper_bound(Transparent<std::string>{expected_key});
+ assert(iter - map.begin() == expected_offset);
};
test_upper_bound(m, "abc", 0);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index a35426caa0fb02..8cd834d9995168 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -19,6 +19,18 @@
#include "test_macros.h"
#include "check_assertion.h"
+template <class... Args>
+void check_invariant(const std::flat_map<Args...>& m) {
+ assert(m.keys().size() == m.values().size());
+ const auto& keys = m.keys();
+ assert(std::is_sorted(keys.begin(), keys.end(), m.key_comp()));
+ auto key_equal = [&](const auto& x, const auto& y) {
+ const auto& c = m.key_comp();
+ return !c(x, y) && !c(y, x);
+ };
+ assert(std::adjacent_find(keys.begin(), keys.end(), key_equal) == keys.end());
+}
+
struct StartsWith {
explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {}
StartsWith(const StartsWith&) = delete;
@@ -160,12 +172,6 @@ struct ThrowOnMoveContainer : std::vector<T> {
ThrowOnMoveContainer& operator=(ThrowOnMoveContainer&&) { throw 42; }
};
-template <class T, class Compare = std::less<>>
-bool is_sorted_and_unique(T&& container, Compare compare = Compare()) {
- auto greater_or_equal_to = [&](const auto& x, const auto& y) { return !compare(x, y); };
- return std::ranges::adjacent_find(container, greater_or_equal_to) == std::ranges::end(container);
-}
-
template <class F>
void test_emplace_exception_guarantee(F&& emplace_function) {
#ifndef TEST_HAS_NO_EXCEPTIONS
@@ -190,8 +196,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
emplace_function(m, 0, 0);
assert(false);
} catch (const std::bad_alloc&) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, the flat_map is unchanged
LIBCPP_ASSERT(m.size() == 4);
LIBCPP_ASSERT(m.keys() == expected_keys);
@@ -211,8 +216,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
emplace_function(m, 0, 0);
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, the flat_map is cleared
LIBCPP_ASSERT(m.size() == 0);
}
@@ -238,8 +242,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
emplace_function(m, 0, 0);
assert(false);
} catch (const std::bad_alloc&) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, the emplaced key is erased and the flat_map is unchanged
LIBCPP_ASSERT(m.size() == 4);
LIBCPP_ASSERT(m.keys() == expected_keys);
@@ -261,8 +264,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
emplace_function(m, 0, 0);
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, the flat_map is cleared
LIBCPP_ASSERT(m.size() == 0);
}
@@ -285,8 +287,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
emplace_function(m, 0, 0);
assert(false);
} catch (const std::bad_alloc&) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we try to erase the key after value emplacement failure.
// and after erasure failure, we clear the flat_map
LIBCPP_ASSERT(m.size() == 0);
@@ -312,8 +313,7 @@ void test_insert_range_exception_guarantee(F&& insert_function) {
insert_function(m, newValues);
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we clear if anything goes wrong when inserting a range
LIBCPP_ASSERT(m.size() == 0);
}
@@ -336,8 +336,7 @@ void test_erase_exception_guarantee(F&& erase_function) {
erase_function(m, 3);
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we clear if anything goes wrong when erasing
LIBCPP_ASSERT(m.size() == 0);
}
@@ -355,8 +354,7 @@ void test_erase_exception_guarantee(F&& erase_function) {
erase_function(m, 3);
assert(false);
} catch (int) {
- assert(m.keys().size() == m.values().size());
- assert(is_sorted_and_unique(m.keys()));
+ check_invariant(m);
// In libc++, we clear if anything goes wrong when erasing
LIBCPP_ASSERT(m.size() == 0);
}
>From 44ec79b093d2b14b52cc5d3cebd171007bee62db Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 19 Oct 2024 16:04:45 +0100
Subject: [PATCH 31/40] ci
---
libcxx/include/__flat_map/flat_map.h | 7 +++----
1 file changed, 3 insertions(+), 4 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 5ca201894dc4b1..42931e9081750c 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -263,10 +263,9 @@ class flat_map {
# if _LIBCPP_HAS_EXCEPTIONS
} catch (...) {
__other.clear();
- if constexpr (is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
- is_nothrow_move_constructible_v<_Compare>) {
- // gcc does not like the `throw` keyword in a conditional noexcept function
- // split the move constructor into two
+ // gcc does not like the `throw` keyword in a conditional noexcept function
+ if constexpr (!(is_nothrow_move_constructible_v<_KeyContainer> &&
+ is_nothrow_move_constructible_v<_MappedContainer> && is_nothrow_move_constructible_v<_Compare>)) {
throw;
}
# endif // _LIBCPP_HAS_EXCEPTIONS
>From 25d917a95c9dee567f7c895e41054f41bc9b72cf Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 20 Oct 2024 09:30:56 +0100
Subject: [PATCH 32/40] ci
---
.../flat.map/flat.map.iterators/iterator_comparison.pass.cpp | 1 -
.../test/std/containers/container.adaptors/flat.map/helpers.h | 3 +++
2 files changed, 3 insertions(+), 1 deletion(-)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
index d22cf7563784eb..1975d0ed86cc8b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp
@@ -29,7 +29,6 @@ void test() {
using Value = typename ValueContainer::value_type;
using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;
using KI = typename KeyContainer::iterator;
- using KCI = typename KeyContainer::const_iterator;
using I = M::iterator;
using CI = M::const_iterator;
using RI = M::reverse_iterator;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 8cd834d9995168..89293818ea5608 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -124,6 +124,7 @@ struct NoDefaultCtr {
NoDefaultCtr() = delete;
};
+#ifndef TEST_HAS_NO_EXCEPTIONS
template <class T>
struct EmplaceUnsafeContainer : std::vector<T> {
using std::vector<T>::vector;
@@ -172,6 +173,8 @@ struct ThrowOnMoveContainer : std::vector<T> {
ThrowOnMoveContainer& operator=(ThrowOnMoveContainer&&) { throw 42; }
};
+#endif
+
template <class F>
void test_emplace_exception_guarantee(F&& emplace_function) {
#ifndef TEST_HAS_NO_EXCEPTIONS
>From 4600ee7aad1389ac4929ecf2f569ca52c5d09529 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 20 Oct 2024 10:16:17 +0100
Subject: [PATCH 33/40] ci
---
libcxx/modules/std/flat_map.inc | 2 ++
1 file changed, 2 insertions(+)
diff --git a/libcxx/modules/std/flat_map.inc b/libcxx/modules/std/flat_map.inc
index 1ab7148acf8fc5..6a86229bceaba9 100644
--- a/libcxx/modules/std/flat_map.inc
+++ b/libcxx/modules/std/flat_map.inc
@@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
export namespace std {
+#if _LIBCPP_STD_VER >= 23
// [flat.map], class template flat_map
using std::flat_map;
@@ -19,6 +20,7 @@ export namespace std {
// [flat.map.erasure], erasure for flat_map
using std::erase_if;
+#endif // _LIBCPP_STD_VER >= 23
#if 0
// [flat.multimap], class template flat_multimap
using std::flat_multimap;
>From e6ed1e53f1dae298f030574de59fe6dea66a32f7 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 20 Oct 2024 12:24:22 +0100
Subject: [PATCH 34/40] ci
---
libcxx/include/__flat_map/flat_map.h | 2 +-
.../flat.map/assert.sorted_unique.pass.cpp | 1 +
.../flat.map.syn/sorted_unique.pass.cpp | 2 ++
.../equal_range_transparent.pass.cpp | 1 +
.../container.adaptors/flat.map/helpers.h | 14 ++++++++------
5 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 42931e9081750c..b01578d07cb66a 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -161,7 +161,7 @@ class flat_map {
: __key_iter_(std::move(__key_iter)), __mapped_iter_(std::move(__mapped_iter)) {}
_LIBCPP_HIDE_FROM_ABI __reference operator*() const { return __reference(*__key_iter_, *__mapped_iter_); }
- _LIBCPP_HIDE_FROM_ABI __arrow_proxy operator->() const { return __arrow_proxy(**this); }
+ _LIBCPP_HIDE_FROM_ABI __arrow_proxy operator->() const { return __arrow_proxy{**this}; }
_LIBCPP_HIDE_FROM_ABI __iterator& operator++() {
++__key_iter_;
diff --git a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
index dcd6314a5c00e4..e6bd3f385af9cb 100644
--- a/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
+++ b/libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp
@@ -8,6 +8,7 @@
// 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_map>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
index f8bbb070b2f91d..c602d2d3d38f79 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp
@@ -39,4 +39,6 @@ constexpr bool test() {
int main(int, char**) {
test();
static_assert(test());
+
+ return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
index dbf74a63d98dcb..0198f433bdc4f1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp
@@ -14,6 +14,7 @@
// template<class K> pair<const_iterator,const_iterator> equal_range(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <string>
#include <utility>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 89293818ea5608..339a718f07546e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -17,7 +17,9 @@
#include "test_allocator.h"
#include "test_macros.h"
-#include "check_assertion.h"
+#if !defined(TEST_HAS_NO_LOCALIZATION)
+# include "check_assertion.h"
+#endif
template <class... Args>
void check_invariant(const std::flat_map<Args...>& m) {
@@ -176,7 +178,7 @@ struct ThrowOnMoveContainer : std::vector<T> {
#endif
template <class F>
-void test_emplace_exception_guarantee(F&& emplace_function) {
+void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) {
#ifndef TEST_HAS_NO_EXCEPTIONS
using C = TransparentComparator;
{
@@ -300,7 +302,7 @@ void test_emplace_exception_guarantee(F&& emplace_function) {
}
template <class F>
-void test_insert_range_exception_guarantee(F&& insert_function) {
+void test_insert_range_exception_guarantee([[maybe_unused]] F&& insert_function) {
#ifndef TEST_HAS_NO_EXCEPTIONS
using KeyContainer = EmplaceUnsafeContainer<int>;
using ValueContainer = std::vector<int>;
@@ -324,7 +326,7 @@ void test_insert_range_exception_guarantee(F&& insert_function) {
}
template <class F>
-void test_erase_exception_guarantee(F&& erase_function) {
+void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) {
#ifndef TEST_HAS_NO_EXCEPTIONS
{
// key erase throws
@@ -366,8 +368,8 @@ void test_erase_exception_guarantee(F&& erase_function) {
}
template <class F>
-void test_swap_exception_guarantee(F&& swap_function) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
+void test_swap_exception_guarantee([[maybe_unused]] F&& swap_function) {
+#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(TEST_HAS_NO_LOCALIZATION)
{
// key swap throws
using KeyContainer = ThrowOnMoveContainer<int>;
>From c1f3d771f614ec15fce960ffef50107ee45c2f40 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 20 Oct 2024 17:12:23 +0100
Subject: [PATCH 35/40] ci
---
.../flat.map/flat.map.cons/alloc.pass.cpp | 16 +-
.../flat.map/flat.map.cons/compare.pass.cpp | 13 +-
.../flat.map.cons/containers.pass.cpp | 122 ------
.../flat.map/flat.map.cons/copy.pass.cpp | 20 -
.../flat.map.cons/copy_alloc.pass.cpp | 29 --
.../flat.map.cons/copy_assign.pass.cpp | 17 -
.../flat.map/flat.map.cons/deduct.pass.cpp | 53 ---
.../flat.map.cons/deduct_pmr.pass.cpp | 106 +++++
.../flat.map.cons/initializer_list.pass.cpp | 26 +-
.../flat.map/flat.map.cons/iter_iter.pass.cpp | 23 +-
.../flat.map.cons/move_alloc.pass.cpp | 32 +-
.../flat.map.cons/move_assign.pass.cpp | 20 -
.../flat.map/flat.map.cons/pmr.pass.cpp | 361 ++++++++++++++++++
.../flat.map/flat.map.cons/range.pass.cpp | 27 +-
.../flat.map.cons/sorted_container.pass.cpp | 41 +-
.../sorted_initializer_list.pass.cpp | 30 +-
.../flat.map.cons/sorted_iter_iter.pass.cpp | 30 +-
.../flat.map.modifiers/clear.pass.cpp | 2 +
.../swap_exception.pass.cpp | 77 ++++
.../flat.map.modifiers/swap_free.pass.cpp | 8 +-
.../flat.map.modifiers/swap_member.pass.cpp | 7 +-
.../count_transparent.pass.cpp | 1 +
.../lower_bound_transparent.pass.cpp | 1 +
.../upper_bound_transparent.pass.cpp | 1 +
.../container.adaptors/flat.map/helpers.h | 41 --
25 files changed, 563 insertions(+), 541 deletions(-)
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
create mode 100644 libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
index 8dee25a24760ae..3f8d2ed332d6b3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp
@@ -16,7 +16,6 @@
#include <cassert>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "test_macros.h"
@@ -68,19 +67,6 @@ int main(int, char**) {
assert(m.keys().get_allocator().get_id() == 5);
assert(m.values().get_allocator().get_id() == 5);
}
- {
- // pmr
- using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::polymorphic_allocator<int> pa = &mr;
- auto m1 = M(pa);
- assert(m1.empty());
- assert(m1.keys().get_allocator() == pa);
- assert(m1.values().get_allocator() == pa);
- auto m2 = M(&mr);
- assert(m2.empty());
- assert(m2.keys().get_allocator() == pa);
- assert(m2.values().get_allocator() == pa);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
index 0e6d156ed9c405..40a1710f55e422 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp
@@ -17,7 +17,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <type_traits>
#include <vector>
@@ -81,17 +80,6 @@ int main(int, char**) {
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
- {
- using M = std::flat_map<int, int, std::function<bool(int, int)>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(std::greater<int>());
- assert(vm[0] == M{});
- assert(vm[0].key_comp()(2, 1) == true);
- assert(vm[0].value_comp()({2, 0}, {1, 0}) == true);
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
{
// If an allocator is given, it must be usable by both containers.
using A = test_allocator<int>;
@@ -100,5 +88,6 @@ int main(int, char**) {
static_assert(!std::is_constructible_v<M, std::less<>, std::allocator<int>>);
static_assert(!std::is_constructible_v<M, std::less<>, A>);
}
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
index 04180ff2b56ca2..812e2c3e4f02a8 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp
@@ -23,7 +23,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "min_allocator.h"
@@ -180,127 +179,6 @@ int main(int, char**) {
assert(m2.keys().get_allocator() == A(5));
assert(m2.values().get_allocator() == A(5));
}
- {
- // pmr
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- assert(ks.get_allocator().resource() != &mr);
- assert(vs.get_allocator().resource() != &mr);
- vm.emplace_back(ks, vs);
- assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
- assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr move
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
- assert(ks.get_allocator().resource() != &mr);
- assert(vs.get_allocator().resource() != &mr);
- vm.emplace_back(std::move(ks), std::move(vs));
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
-#if 0
- // Test all combinations of lvalue and rvalue containers (LWG 3802).
- {
- int input[] = {1,1,1,2,2,3,2,3,3};
- const P expected[] = {{1,1}, {2,2}, {3,3}};
- {
- using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks(input, input + 9);
- std::pmr::vector<MoveOnly> vs(input, input + 9);
- vm.emplace_back(ks, std::move(vs)); // ill-formed before LWG 3802
- assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 9);
- std::pmr::vector<int> vs(input, input + 9);
- vm.emplace_back(std::move(ks), vs); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 9);
- std::pmr::vector<MoveOnly> vs(input, input + 9);
- vm.emplace_back(std::move(ks), std::move(vs)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- }
- {
- int input[] = {1,2,3};
- const P expected[] = {{1,1}, {2,2}, {3,3}};
- {
- using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks(input, input + 3);
- std::pmr::vector<MoveOnly> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, ks, std::move(vs)); // ill-formed before LWG 3802
- assert(ks.size() == 3); // ks' value is unchanged, since it was an lvalue above
- LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 3);
- std::pmr::vector<int> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, std::move(ks), vs); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
- assert(vs.size() == 3); // vs' value is unchanged, since it was an lvalue above
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<MoveOnly> ks(input, input + 3);
- std::pmr::vector<MoveOnly> vs(input, input + 3);
- vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs)); // ill-formed before LWG 3802
- LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
- assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- }
-#endif
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
index a09e10e63b6561..fcd0415088c1c9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp
@@ -14,7 +14,6 @@
#include <cassert>
#include <flat_map>
-#include <memory_resource>
#include <vector>
#include "test_macros.h"
@@ -66,25 +65,6 @@ int main(int, char**) {
assert(mo.keys().get_allocator() == other_allocator<int>(6));
assert(mo.values().get_allocator() == other_allocator<char>(7));
}
- {
- using C = test_less<int>;
- std::pmr::monotonic_buffer_resource mr;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- auto mo = M({{1, 1}, {2, 2}, {3, 3}}, C(5), &mr);
- auto m = mo;
-
- assert(m.key_comp() == C(5));
- assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
- auto [ks, vs] = std::move(m).extract();
- assert(ks.get_allocator().resource() == std::pmr::get_default_resource());
- assert(vs.get_allocator().resource() == std::pmr::get_default_resource());
- // mo is unchanged
- assert(mo.key_comp() == C(5));
- assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
- auto [kso, vso] = std::move(mo).extract();
- assert(kso.get_allocator().resource() == &mr);
- assert(vso.get_allocator().resource() == &mr);
- }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
index 2b01243622da9a..cbda6ea853268a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp
@@ -16,7 +16,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "test_macros.h"
@@ -63,34 +62,6 @@ int main(int, char**) {
assert(mo.keys().get_allocator() == test_allocator<int>(6));
assert(mo.values().get_allocator() == test_allocator<char>(7));
}
- {
- // explicit(false)
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr1;
- std::pmr::monotonic_buffer_resource mr2;
- M mo = M({1, 2, 3}, {2, 2, 1}, C(5), &mr1);
- M m = {mo, &mr2}; // also test the implicitness of this constructor
- assert(m.key_comp() == C(5));
- assert((m.keys() == std::pmr::vector<int>{1, 2, 3}));
- assert((m.values() == std::pmr::vector<int>{2, 2, 1}));
- assert(m.keys().get_allocator().resource() == &mr2);
- assert(m.values().get_allocator().resource() == &mr2);
-
- // mo is unchanged
- assert(mo.key_comp() == C(5));
- assert((mo.keys() == std::pmr::vector<int>{1, 2, 3}));
- assert((mo.values() == std::pmr::vector<int>{2, 2, 1}));
- assert(mo.keys().get_allocator().resource() == &mr1);
- assert(mo.values().get_allocator().resource() == &mr1);
- }
- {
- using M = std::flat_map<int, int, std::less<>, std::pmr::vector<int>, std::pmr::deque<int>>;
- std::pmr::vector<M> vs;
- M m = {{1, 2}, {2, 2}, {3, 1}};
- vs.push_back(m);
- assert(vs[0] == m);
- }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
index 4f429bdc204c7a..4f9797d5bf810a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
@@ -15,7 +15,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "test_macros.h"
@@ -71,22 +70,6 @@ int main(int, char**) {
assert(mo.keys().get_allocator() == other_allocator<int>(6));
assert(mo.values().get_allocator() == other_allocator<char>(7));
}
- {
- // pmr allocator is not propagated
- using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr1;
- std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{1, 1}, {2, 2}, {3, 3}}, &mr1);
- M m = M({{4, 4}, {5, 5}}, &mr2);
- m = mo;
- assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(m.keys().get_allocator().resource() == &mr2);
- assert(m.values().get_allocator().resource() == &mr2);
-
- // mo is unchanged
- assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
- assert(mo.keys().get_allocator().resource() == &mr1);
- }
{
// comparator is copied and invariant is preserved
using M = std::flat_map<int, int, std::function<bool(int, int)>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
index 4013c706354826..d01bee9aae9c08 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -18,7 +18,6 @@
#include <list>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <ranges>
#include <type_traits>
#include <utility>
@@ -89,32 +88,6 @@ void test_containers() {
assert(s.keys().get_allocator().get_id() == 44);
assert(s.values().get_allocator().get_id() == 44);
}
- {
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::monotonic_buffer_resource mr2;
- std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
- std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
- std::flat_map s(std::move(pks), std::move(pvs), &mr2);
-
- ASSERT_SAME_TYPE(
- decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
- assert(std::ranges::equal(s, expected));
- assert(s.keys().get_allocator().resource() == &mr2);
- assert(s.values().get_allocator().resource() == &mr2);
- }
- {
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::monotonic_buffer_resource mr2;
- std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
- std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
- std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
-
- ASSERT_SAME_TYPE(
- decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
- assert(std::ranges::equal(s, expected));
- assert(s.keys().get_allocator().resource() == &mr2);
- assert(s.values().get_allocator().resource() == &mr2);
- }
}
void test_containers_compare() {
@@ -155,32 +128,6 @@ void test_containers_compare() {
assert(s.keys().get_allocator().get_id() == 44);
assert(s.values().get_allocator().get_id() == 44);
}
- {
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::monotonic_buffer_resource mr2;
- std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
- std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
- std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
-
- ASSERT_SAME_TYPE(
- decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
- assert(std::ranges::equal(s, expected));
- assert(s.keys().get_allocator().resource() == &mr2);
- assert(s.values().get_allocator().resource() == &mr2);
- }
- {
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::monotonic_buffer_resource mr2;
- std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
- std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
- std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
-
- ASSERT_SAME_TYPE(
- decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
- assert(std::ranges::equal(s, expected));
- assert(s.keys().get_allocator().resource() == &mr2);
- assert(s.values().get_allocator().resource() == &mr2);
- }
}
void test_iter_iter() {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
new file mode 100644
index 00000000000000..11c18ac13c76a9
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: availability-pmr-missing
+
+// <flat_map>
+
+#include <algorithm>
+#include <cassert>
+#include <climits>
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+void test_containers() {
+ std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
+ std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
+ std::flat_map s(std::move(pks), std::move(pvs), &mr2);
+
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
+ std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
+ std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
+
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+}
+
+void test_containers_compare() {
+ std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
+ std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
+ std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
+ const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
+ std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
+ std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
+
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+ {
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::monotonic_buffer_resource mr2;
+ std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
+ std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
+ std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
+
+ ASSERT_SAME_TYPE(
+ decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
+ assert(std::ranges::equal(s, expected));
+ assert(s.keys().get_allocator().resource() == &mr2);
+ assert(s.values().get_allocator().resource() == &mr2);
+ }
+}
+
+int main(int, char**) {
+ test_containers();
+ test_containers_compare();
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
index 379d1723705eb7..7a22746845d002 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
@@ -20,7 +20,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <type_traits>
#include <vector>
@@ -153,29 +152,6 @@ int main(int, char**) {
M m({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, {}, a);
assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
}
- {
- // pmr
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
- vm.emplace_back(il);
- assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr compartor
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
- vm.emplace_back(il, C(5));
- assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- assert(vm[0].key_comp() == C(5));
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
index dc5d8ee560a178..7c0c487969943d 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -21,7 +21,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "min_allocator.h"
@@ -150,26 +149,6 @@ int main(int, char**) {
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
- {
- // pmr cpp17 iterator
- using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
- assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr
- using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(ar, ar);
- assert(vm[0].empty());
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
index 807352bc4cda1b..93a39764225200 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp
@@ -16,7 +16,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <ranges>
#include <vector>
@@ -67,36 +66,6 @@ int main(int, char**) {
assert(mo.keys().get_allocator() == A(7));
assert(mo.values().get_allocator() == A(7));
}
- {
- // explicit(false)
- std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
- std::pmr::monotonic_buffer_resource mr1;
- std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{1, 1}, {3, 1}, {1, 1}, {2, 2}}, C(5), &mr1);
- M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor
-
- assert(m.key_comp() == C(5));
- assert(m.size() == 3);
- assert(m.keys().get_allocator().resource() == &mr2);
- assert(m.values().get_allocator().resource() == &mr2);
- assert(std::equal(m.begin(), m.end(), expected, expected + 3));
-
- // The original flat_map is moved-from.
- assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- assert(mo.key_comp() == C(5));
- assert(mo.keys().get_allocator().resource() == &mr1);
- assert(mo.values().get_allocator().resource() == &mr1);
- }
- {
- using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
- std::pmr::vector<M> vs;
- M m = {{1, 1}, {3, 1}, {1, 1}, {2, 2}};
- vs.push_back(std::move(m));
- assert((vs[0].keys() == std::pmr::deque<int>{1, 2, 3}));
- assert((vs[0].values() == std::pmr::vector<int>{1, 2, 1}));
- }
{
// moved-from object maintains invariant if one of underlying container does not clear after move
using M = std::flat_map<int, int, std::less<>, std::vector<int>, CopyOnlyVector<int>>;
@@ -108,5 +77,6 @@ int main(int, char**) {
LIBCPP_ASSERT(m1.keys().size() == 0);
LIBCPP_ASSERT(m1.values().size() == 0);
}
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
index 66af84b6bf2b7f..a94c442c695ddb 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
@@ -16,7 +16,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <string>
#include <utility>
#include <vector>
@@ -70,25 +69,6 @@ int main(int, char**) {
assert(vs.get_allocator() == A());
assert(mo.empty());
}
- {
- // A moved-from flat_map maintains its class invariant in the presence of moved-from elements.
- using M =
- std::flat_map<std::pmr::string, int, std::less<>, std::pmr::vector<std::pmr::string>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr1;
- std::pmr::monotonic_buffer_resource mr2;
- M mo = M({{"short", 1},
- {"very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move", 2}},
- &mr1);
- M m = M({{"don't care", 3}}, &mr2);
- m = std::move(mo);
- assert(m.size() == 2);
- assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
- assert(m.begin()->first.get_allocator().resource() == &mr2);
-
- assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
- mo.insert({"foo", 1});
- assert(mo.begin()->first.get_allocator().resource() == &mr1);
- }
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
new file mode 100644
index 00000000000000..154af11bb9b4db
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
@@ -0,0 +1,361 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: availability-pmr-missing
+
+// <flat_map>
+
+// Test various constructors with pmr
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory_resource>
+#include <ranges>
+#include <vector>
+#include <string>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "../../../test_compare.h"
+
+int main(int, char**) {
+ {
+ // flat_map(const Allocator& a);
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::polymorphic_allocator<int> pa = &mr;
+ auto m1 = M(pa);
+ assert(m1.empty());
+ assert(m1.keys().get_allocator() == pa);
+ assert(m1.values().get_allocator() == pa);
+ auto m2 = M(&mr);
+ assert(m2.empty());
+ assert(m2.keys().get_allocator() == pa);
+ assert(m2.values().get_allocator() == pa);
+ }
+ {
+ // flat_map(const key_compare& comp, const Alloc& a);
+ using M = std::flat_map<int, int, std::function<bool(int, int)>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::greater<int>());
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp()(2, 1) == true);
+ assert(vm[0].value_comp()({2, 0}, {1, 0}) == true);
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+ // const Allocator& a);
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+ assert(ks.get_allocator().resource() != &mr);
+ assert(vs.get_allocator().resource() != &mr);
+ vm.emplace_back(ks, vs);
+ assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
+ assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
+ assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(const flat_map&, const allocator_type&);
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({1, 2, 3}, {2, 2, 1}, C(5), &mr1);
+ M m = {mo, &mr2}; // also test the implicitness of this constructor
+
+ assert(m.key_comp() == C(5));
+ assert((m.keys() == std::pmr::vector<int>{1, 2, 3}));
+ assert((m.values() == std::pmr::vector<int>{2, 2, 1}));
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert((mo.keys() == std::pmr::vector<int>{1, 2, 3}));
+ assert((mo.values() == std::pmr::vector<int>{2, 2, 1}));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ assert(mo.values().get_allocator().resource() == &mr1);
+ }
+ {
+ // flat_map(const flat_map&, const allocator_type&);
+ using M = std::flat_map<int, int, std::less<>, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::vector<M> vs;
+ M m = {{1, 2}, {2, 2}, {3, 1}};
+ vs.push_back(m);
+ assert(vs[0] == m);
+ }
+ {
+ // flat_map& operator=(const flat_map& m);
+ // pmr allocator is not propagated
+ using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{1, 1}, {2, 2}, {3, 3}}, &mr1);
+ M m = M({{4, 4}, {5, 5}}, &mr2);
+ m = mo;
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+
+ // mo is unchanged
+ assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ }
+ {
+ // flat_map(const flat_map& m);
+ using C = test_less<int>;
+ std::pmr::monotonic_buffer_resource mr;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ auto mo = M({{1, 1}, {2, 2}, {3, 3}}, C(5), &mr);
+ auto m = mo;
+
+ assert(m.key_comp() == C(5));
+ assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
+ auto [ks, vs] = std::move(m).extract();
+ assert(ks.get_allocator().resource() == std::pmr::get_default_resource());
+ assert(vs.get_allocator().resource() == std::pmr::get_default_resource());
+
+ // mo is unchanged
+ assert(mo.key_comp() == C(5));
+ assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
+ auto [kso, vso] = std::move(mo).extract();
+ assert(kso.get_allocator().resource() == &mr);
+ assert(vso.get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(initializer_list<value_type> il, const Alloc& a);
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
+ vm.emplace_back(il);
+ assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::initializer_list<M::value_type> il = {{3, 3}, {1, 1}, {4, 4}, {1, 1}, {5, 5}};
+ vm.emplace_back(il, C(5));
+ assert((vm[0] == M{{1, 1}, {3, 3}, {4, 4}, {5, 5}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ assert(vm[0].key_comp() == C(5));
+ }
+ {
+ // flat_map(InputIterator first, InputIterator last, const Allocator& a);
+ using P = std::pair<int, short>;
+ P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
+ P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+ {
+ // cpp17 iterator
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 9));
+ assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(ar, ar);
+ assert(vm[0].empty());
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ {
+ // flat_map(flat_map&&, const allocator_type&);
+ std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 1}};
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::deque<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{1, 1}, {3, 1}, {1, 1}, {2, 2}}, C(5), &mr1);
+ M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor
+
+ assert(m.key_comp() == C(5));
+ assert(m.size() == 3);
+ assert(m.keys().get_allocator().resource() == &mr2);
+ assert(m.values().get_allocator().resource() == &mr2);
+ assert(std::equal(m.begin(), m.end(), expected, expected + 3));
+
+ // The original flat_map is moved-from.
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ assert(mo.key_comp() == C(5));
+ assert(mo.keys().get_allocator().resource() == &mr1);
+ assert(mo.values().get_allocator().resource() == &mr1);
+ }
+ {
+ // flat_map(flat_map&&, const allocator_type&);
+ using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
+ std::pmr::vector<M> vs;
+ M m = {{1, 1}, {3, 1}, {1, 1}, {2, 2}};
+ vs.push_back(std::move(m));
+ assert((vs[0].keys() == std::pmr::deque<int>{1, 2, 3}));
+ assert((vs[0].values() == std::pmr::vector<int>{1, 2, 1}));
+ }
+ {
+ // flat_map& operator=(flat_map&&);
+ using M =
+ std::flat_map<std::pmr::string, int, std::less<>, std::pmr::vector<std::pmr::string>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr1;
+ std::pmr::monotonic_buffer_resource mr2;
+ M mo = M({{"short", 1},
+ {"very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move", 2}},
+ &mr1);
+ M m = M({{"don't care", 3}}, &mr2);
+ m = std::move(mo);
+ assert(m.size() == 2);
+ assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));
+ assert(m.begin()->first.get_allocator().resource() == &mr2);
+
+ assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));
+ mo.insert({"foo", 1});
+ assert(mo.begin()->first.get_allocator().resource() == &mr1);
+ }
+ {
+ // flat_map(from_range_t, R&&, const Alloc&);
+ using P = std::pair<int, short>;
+ P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
+ P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+ {
+ // input_range
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ using Iter = cpp20_input_iterator<const P*>;
+ using Sent = sentinel_wrapper<Iter>;
+ using R = std::ranges::subrange<Iter, Sent>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));
+ assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
+ LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
+ using R = std::ranges::subrange<const P*>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ vm.emplace_back(std::from_range, R(ar, ar));
+ assert(vm[0].empty());
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ }
+ {
+ // flat_map(sorted_unique_t, const key_container_type& key_cont,
+ // const mapped_container_type& mapped_cont, const Alloc& a);
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks = {1, 2, 4, 10};
+ std::pmr::vector<int> vs = {4, 3, 2, 1};
+ vm.emplace_back(std::sorted_unique, ks, vs);
+ assert(!ks.empty()); // it was an lvalue above
+ assert(!vs.empty()); // it was an lvalue above
+ assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(sorted_unique_t, const key_container_type& key_cont,
+ // const mapped_container_type& mapped_cont, const Alloc& a);
+ using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pmr::vector<int> ks({1, 2, 4, 10}, &mr);
+ std::pmr::vector<int> vs({4, 3, 2, 1}, &mr);
+ vm.emplace_back(std::sorted_unique, ks, vs);
+ assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+ // cpp_17
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ vm.emplace_back(
+ std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+ assert(vm[0].key_comp() == C(3));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pair<int, int> ar[1] = {{42, 42}};
+ vm.emplace_back(std::sorted_unique, ar, ar, C(4));
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp() == C(4));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(InputIterator first, InputIterator last, const Alloc& a);
+ // cpp_17
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ using P = std::pair<int, int>;
+ P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+ vm.emplace_back(
+ std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
+ assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+ assert(vm[0].key_comp() == C(3));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+ {
+ // flat_map(InputIterator first, InputIterator last, const Alloc& a);
+ using C = test_less<int>;
+ using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
+ std::pmr::monotonic_buffer_resource mr;
+ std::pmr::vector<M> vm(&mr);
+ std::pair<int, int> ar[1] = {{42, 42}};
+ vm.emplace_back(std::sorted_unique, ar, ar, C(4));
+ assert(vm[0] == M{});
+ assert(vm[0].key_comp() == C(4));
+ assert(vm[0].keys().get_allocator().resource() == &mr);
+ assert(vm[0].values().get_allocator().resource() == &mr);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
index 694a43fd9daa9a..282cc71f31994f 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
@@ -23,7 +23,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <string>
#include <vector>
@@ -223,30 +222,6 @@ int main(int, char**) {
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
- {
- // pmr input_range
- using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
- using Iter = cpp20_input_iterator<const P*>;
- using Sent = sentinel_wrapper<Iter>;
- using R = std::ranges::subrange<Iter, Sent>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));
- assert(std::ranges::equal(vm[0].keys(), expected | std::views::elements<0>));
- LIBCPP_ASSERT(std::ranges::equal(vm[0], expected));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr
- using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
- using R = std::ranges::subrange<const P*>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- vm.emplace_back(std::from_range, R(ar, ar));
- assert(vm[0].empty());
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index cb408214a8a951..3c8868f2ff4247 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -24,7 +24,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "min_allocator.h"
@@ -161,44 +160,6 @@ int main(int, char**) {
assert(m2.keys().get_allocator() == A(6));
assert(m2.values().get_allocator() == A(6));
}
- {
- // pmr
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 2, 4, 10};
- std::pmr::vector<int> vs = {4, 3, 2, 1};
- vm.emplace_back(std::sorted_unique, ks, vs);
- assert(!ks.empty()); // it was an lvalue above
- assert(!vs.empty()); // it was an lvalue above
- assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr move
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks = {1, 2, 4, 10};
- std::pmr::vector<int> vs = {4, 3, 2, 1};
- vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
- LIBCPP_ASSERT(ks.size() == 4); // ks' size is unchanged, since it uses a different allocator
- LIBCPP_ASSERT(vs.size() == 4); // vs' size is unchanged, since it uses a different allocator
- assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pmr::vector<int> ks({1, 2, 4, 10}, &mr);
- std::pmr::vector<int> vs({4, 3, 2, 1}, &mr);
- vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs));
- assert((vm[0] == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
index 8f6a2e771f85b9..26452472ba2011 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
@@ -22,7 +22,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "min_allocator.h"
@@ -175,33 +174,6 @@ int main(int, char**) {
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
- {
- // pmr cpp_17
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- using P = std::pair<int, int>;
- P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- vm.emplace_back(
- std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
- assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
- assert(vm[0].key_comp() == C(3));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pair<int, int> ar[1] = {{42, 42}};
- vm.emplace_back(std::sorted_unique, ar, ar, C(4));
- assert(vm[0] == M{});
- assert(vm[0].key_comp() == C(4));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
index 2232e0b60455ae..8eb7547e917cca 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
@@ -20,7 +20,6 @@
#include <deque>
#include <flat_map>
#include <functional>
-#include <memory_resource>
#include <vector>
#include "min_allocator.h"
@@ -167,33 +166,6 @@ int main(int, char**) {
assert(m.keys().get_allocator() == A1(5));
assert(m.values().get_allocator() == A2(5));
}
- {
- // pmr cpp_17
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- using P = std::pair<int, int>;
- P ar[] = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
- vm.emplace_back(
- std::sorted_unique, cpp17_input_iterator<const P*>(ar), cpp17_input_iterator<const P*>(ar + 4), C(3));
- assert((vm[0] == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
- assert(vm[0].key_comp() == C(3));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
- {
- // pmr
- using C = test_less<int>;
- using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
- std::pmr::monotonic_buffer_resource mr;
- std::pmr::vector<M> vm(&mr);
- std::pair<int, int> ar[1] = {{42, 42}};
- vm.emplace_back(std::sorted_unique, ar, ar, C(4));
- assert(vm[0] == M{});
- assert(vm[0].key_comp() == C(4));
- assert(vm[0].keys().get_allocator().resource() == &mr);
- assert(vm[0].values().get_allocator().resource() == &mr);
- }
+
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
index 4ae8800e99c92e..30271eb55660bf 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp
@@ -33,8 +33,10 @@ concept NoExceptClear = requires(T t) {
};
static_assert(NoExceptClear<std::flat_map<int, int>>);
+#ifndef TEST_HAS_NO_EXCEPTIONS
static_assert(
NoExceptClear<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+#endif
template <class KeyContainer, class ValueContainer>
void test() {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
new file mode 100644
index 00000000000000..7799cb8d40361a
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// `check_assertion.h` requires Unix headers and regex support.
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: no-localization
+
+// <flat_map>
+
+// void swap(flat_map& y) noexcept;
+// friend void swap(flat_map& x, flat_map& y) noexcept
+
+// Test that std::terminate is called if any exception is thrown during swap
+
+#include <flat_map>
+#include <cassert>
+#include <deque>
+#include <functional>
+#include <vector>
+
+#include "test_macros.h"
+#include "../helpers.h"
+#include "check_assertion.h"
+
+template <class F>
+void test_swap_exception_guarantee([[maybe_unused]] F&& swap_function) {
+ {
+ // key swap throws
+ using KeyContainer = ThrowOnMoveContainer<int>;
+ using ValueContainer = std::vector<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m1, m2;
+ m1.emplace(1, 1);
+ m1.emplace(2, 2);
+ m2.emplace(3, 3);
+ m2.emplace(4, 4);
+ // swap is noexcept
+ EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
+ }
+
+ {
+ // value swap throws
+ using KeyContainer = std::vector<int>;
+ using ValueContainer = ThrowOnMoveContainer<int>;
+ using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
+
+ M m1, m2;
+ m1.emplace(1, 1);
+ m1.emplace(2, 2);
+ m2.emplace(3, 3);
+ m2.emplace(4, 4);
+
+ // swap is noexcept
+ EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
+ }
+}
+
+int main(int, char**) {
+ {
+ auto swap_func = [](auto& m1, auto& m2) { swap(m1, m2); };
+ test_swap_exception_guarantee(swap_func);
+ }
+
+ {
+ auto swap_func = [](auto& m1, auto& m2) { m1.swap(m2); };
+ test_swap_exception_guarantee(swap_func);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
index 4999c9f164994b..98c60c1488cf53 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
@@ -32,8 +32,11 @@ concept NoExceptAdlSwap = requires(T t1, T t2) {
};
static_assert(NoExceptAdlSwap<std::flat_map<int, int>>);
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
static_assert(
NoExceptAdlSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+#endif
template <class KeyContainer, class ValueContainer>
void test() {
@@ -90,10 +93,5 @@ int main(int, char**) {
test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
- {
- auto swap_func = [](auto& m1, auto& m2) { swap(m1, m2); };
- test_swap_exception_guarantee(swap_func);
- }
-
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
index 667a0180865582..d2d8f5673edeb4 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp
@@ -32,8 +32,10 @@ concept NoExceptMemberSwap = requires(T t1, T t2) {
};
static_assert(NoExceptMemberSwap<std::flat_map<int, int>>);
+#ifndef TEST_HAS_NO_EXCEPTIONS
static_assert(
NoExceptMemberSwap<std::flat_map<int, int, std::less<int>, ThrowOnMoveContainer<int>, ThrowOnMoveContainer<int>>>);
+#endif
template <class KeyContainer, class ValueContainer>
void test() {
@@ -89,10 +91,5 @@ int main(int, char**) {
test<MinSequenceContainer<int>, MinSequenceContainer<double>>();
test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();
- {
- auto swap_func = [](auto& m1, auto& m2) { m1.swap(m2); };
- test_swap_exception_guarantee(swap_func);
- }
-
return 0;
}
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
index 9c04aa0a549456..cd195ff1fa8b43 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp
@@ -13,6 +13,7 @@
// template<class K> size_type count(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <string>
#include <utility>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
index 7eab72c7a61ee5..6a923c197e91ea 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp
@@ -14,6 +14,7 @@
// template<class K> const_iterator lower_bound(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <string>
#include <utility>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
index ebc6f8f61acfad..4e83f920835dff 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp
@@ -14,6 +14,7 @@
// template<class K> const_iterator upper_bound(const K& x) const;
#include <cassert>
+#include <deque>
#include <flat_map>
#include <string>
#include <utility>
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
index 339a718f07546e..8dbb85a6c0acf1 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h
@@ -17,9 +17,6 @@
#include "test_allocator.h"
#include "test_macros.h"
-#if !defined(TEST_HAS_NO_LOCALIZATION)
-# include "check_assertion.h"
-#endif
template <class... Args>
void check_invariant(const std::flat_map<Args...>& m) {
@@ -366,44 +363,6 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) {
}
#endif
}
-
-template <class F>
-void test_swap_exception_guarantee([[maybe_unused]] F&& swap_function) {
-#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(TEST_HAS_NO_LOCALIZATION)
- {
- // key swap throws
- using KeyContainer = ThrowOnMoveContainer<int>;
- using ValueContainer = std::vector<int>;
- using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
-
- M m1, m2;
- m1.emplace(1, 1);
- m1.emplace(2, 2);
- m2.emplace(3, 3);
- m2.emplace(4, 4);
- // swap is noexcept
- EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
- }
-
- {
- // value swap throws
- using KeyContainer = std::vector<int>;
- using ValueContainer = ThrowOnMoveContainer<int>;
- using M = std::flat_map<int, int, TransparentComparator, KeyContainer, ValueContainer>;
-
- M m1, m2;
- m1.emplace(1, 1);
- m1.emplace(2, 2);
- m2.emplace(3, 3);
- m2.emplace(4, 4);
-
- // swap is noexcept
- EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); });
- }
-
-#endif
-}
-
class Moveable {
int int_;
double double_;
>From 5210813f6779449e6ef6dfab4217e3ef16e41a8b Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sun, 20 Oct 2024 18:53:57 +0100
Subject: [PATCH 36/40] ci
---
.../flat.map/flat.map.modifiers/swap_exception.pass.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
index 7799cb8d40361a..f9708aac62c7ee 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_exception.pass.cpp
@@ -10,6 +10,7 @@
// `check_assertion.h` requires Unix headers and regex support.
// REQUIRES: has-unix-headers
// UNSUPPORTED: no-localization
+// UNSUPPORTED: no-exceptions
// <flat_map>
>From f15aba13a0deb6834553c2bf51be53844d1ce8e2 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 26 Oct 2024 11:00:33 +0100
Subject: [PATCH 37/40] review comments
---
libcxx/docs/ReleaseNotes/20.rst | 1 +
libcxx/include/__flat_map/flat_map.h | 35 +++++++++++--------
.../reverse_iterator.pass.cpp | 30 +---------------
3 files changed, 22 insertions(+), 44 deletions(-)
diff --git a/libcxx/docs/ReleaseNotes/20.rst b/libcxx/docs/ReleaseNotes/20.rst
index 39546493ae8d6f..17bcd91574617d 100644
--- a/libcxx/docs/ReleaseNotes/20.rst
+++ b/libcxx/docs/ReleaseNotes/20.rst
@@ -43,6 +43,7 @@ Implemented Papers
- P2985R0: A type trait for detecting virtual base classes (`Github <https://github.com/llvm/llvm-project/issues/105432>`__)
- ``std::jthread`` and ``<stop_token>`` are not guarded behind ``-fexperimental-library`` anymore
- P2674R1: A trait for implicit lifetime types (`Github <https://github.com/llvm/llvm-project/issues/105259>`__)
+- P0429R9: A Standard ``flat_map`` is partially implemented and ``flat_map`` is provided (`https://github.com/llvm/llvm-project/issues/105190`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index b01578d07cb66a..a1f13d27e9845b 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -249,9 +249,6 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI flat_map(const flat_map&) = default;
- // The copy/move constructors are not specified in the spec, which means they should be defaulted.
- // However, the move constructor can potentially leave a moved-from object in an inconsistent
- // state if an exception is thrown.
_LIBCPP_HIDE_FROM_ABI flat_map(flat_map&& __other) noexcept(
is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
is_nothrow_move_constructible_v<_Compare>)
@@ -491,19 +488,21 @@ class flat_map {
return *this;
}
- // copy/move assignment are not specified in the spec (defaulted)
- // but move assignment can potentially leave moved from object in an inconsistent
- // state if an exception is thrown
_LIBCPP_HIDE_FROM_ABI flat_map& operator=(const flat_map&) = default;
_LIBCPP_HIDE_FROM_ABI flat_map& operator=(flat_map&& __other) noexcept(
is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_MappedContainer> &&
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 */; });
- auto __clear_self_guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
- __containers_ = std::move(__other.__containers_);
- __compare_ = std::move(__other.__compare_);
- __clear_self_guard.__complete();
+ {
+ // 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 */; });
+ __containers_ = std::move(__other.__containers_);
+ __compare_ = std::move(__other.__compare_);
+ __on_exception.__complete();
+ }
return *this;
}
@@ -568,7 +567,7 @@ class flat_map {
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const key_type&): Key does not exist");
}
- return (*__it).second;
+ return __it->second;
}
_LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __x) const {
@@ -576,7 +575,7 @@ class flat_map {
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const key_type&) const: Key does not exist");
}
- return (*__it).second;
+ return __it->second;
}
template <class _Kp>
@@ -586,7 +585,7 @@ class flat_map {
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const K&): Key does not exist");
}
- return (*__it).second;
+ return __it->second;
}
template <class _Kp>
@@ -596,7 +595,7 @@ class flat_map {
if (__it == end()) {
std::__throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
}
- return (*__it).second;
+ return __it->second;
}
// [flat.map.modifiers], modifiers
@@ -805,7 +804,8 @@ class flat_map {
_LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
// warning: The spec has unconditional noexcept, which means that
// if any of the following functions throw an exception,
- // std::terminate will be called
+ // std::terminate will be called.
+ // This is discussed in P2767, which hasn't been voted on yet.
ranges::swap(__compare_, __y.__compare_);
ranges::swap(__containers_.keys, __y.__containers_.keys);
ranges::swap(__containers_.values, __y.__containers_.values);
@@ -956,8 +956,13 @@ class flat_map {
return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container);
}
+ // This function is only used in constructors. So there is not exception handling in this function.
+ // If the function exits via an exception, there will be no flat_map object constructed, thus, there
+ // is no invariant state to preserve
_LIBCPP_HIDE_FROM_ABI void __sort_and_unique() {
auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
+ // To be consistent with std::map's behaviour, we use stable_sort instead of sort.
+ // As a result, if there are duplicated keys, the first value in the original order will be taken.
ranges::stable_sort(__zv, __compare_, [](const auto& __p) -> decltype(auto) { return std::get<0>(__p); });
auto __dup_start = ranges::unique(__zv, __key_equiv(__compare_)).begin();
auto __dist = ranges::distance(__zv.begin(), __dup_start);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
index e5531ee28f6e47..09e18986a7e813 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp
@@ -70,35 +70,6 @@ int main(int, char**) {
}
assert(i == m.rbegin());
}
-// std::string is not a sequence container
-#if 0
- {
- using M = std::flat_map<short, char, std::less<>, std::deque<short>, std::string>;
- const M m = {{1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}};
- ASSERT_SAME_TYPE(decltype(m.rbegin()), M::const_reverse_iterator);
- ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator);
- ASSERT_SAME_TYPE(decltype(m.rend()), M::const_reverse_iterator);
- ASSERT_SAME_TYPE(decltype(m.crend()), M::const_reverse_iterator);
- assert(m.size() == 4);
- assert(std::distance(m.rbegin(), m.rend()) == 4);
- assert(std::distance(m.crbegin(), m.crend()) == 4);
- M::const_reverse_iterator i; // default-construct
- ASSERT_SAME_TYPE(decltype(i->first), const short&);
- ASSERT_SAME_TYPE(decltype(i->second), const char&);
- i = m.rbegin(); // move-assignment
- for (int j = 4; j >= 1; --j, ++i) { // pre-increment
- assert(i->first == j);
- assert(i->second == 'a' + j - 1);
- }
- assert(i == m.rend());
- for (int j = 1; j <= 4; ++j) {
- --i; // pre-decrement
- assert((*i).first == j);
- assert((*i).second == 'a' + j - 1);
- }
- assert(i == m.rbegin());
- }
-#endif
{
// N3644 testing
using C = std::flat_map<int, char>;
@@ -114,5 +85,6 @@ int main(int, char**) {
assert(!(ii1 != cii));
assert(!(cii != ii1));
}
+
return 0;
}
>From f2ee7a91a5a7542439b2b4b02c90136d0ee2ae72 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 26 Oct 2024 11:05:47 +0100
Subject: [PATCH 38/40] review comments
---
libcxx/include/__flat_map/flat_map.h | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index a1f13d27e9845b..26765d01c5d515 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -600,8 +600,7 @@ class flat_map {
// [flat.map.modifiers], modifiers
template <class... _Args>
- requires is_constructible_v<pair<key_type, mapped_type>, _Args...> && is_move_constructible_v<key_type> &&
- is_move_constructible_v<mapped_type>
+ requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
return __try_emplace(std::move(__pair.first), std::move(__pair.second));
>From bac0f3cc7e28bce24b36df1da2c1c12b4b20516d Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 26 Oct 2024 12:42:22 +0100
Subject: [PATCH 39/40] ci
---
libcxx/include/__flat_map/flat_map.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 26765d01c5d515..2a21ccacfa0e03 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -48,6 +48,7 @@
#include <__type_traits/is_nothrow_constructible.h>
#include <__type_traits/is_same.h>
#include <__type_traits/maybe_const.h>
+#include <__utility/exception_guard.h>
#include <__utility/pair.h>
#include <initializer_list>
#include <stdexcept>
>From 74625a17fdef6579a3729bab8efdd30837015fa3 Mon Sep 17 00:00:00 2001
From: Hui <hui.xie0621 at gmail.com>
Date: Sat, 26 Oct 2024 13:46:43 +0100
Subject: [PATCH 40/40] ci
---
libcxx/docs/ReleaseNotes/20.rst | 2 +-
libcxx/include/__flat_map/flat_map.h | 1 +
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/libcxx/docs/ReleaseNotes/20.rst b/libcxx/docs/ReleaseNotes/20.rst
index 17bcd91574617d..dd0863e4d38857 100644
--- a/libcxx/docs/ReleaseNotes/20.rst
+++ b/libcxx/docs/ReleaseNotes/20.rst
@@ -43,7 +43,7 @@ Implemented Papers
- P2985R0: A type trait for detecting virtual base classes (`Github <https://github.com/llvm/llvm-project/issues/105432>`__)
- ``std::jthread`` and ``<stop_token>`` are not guarded behind ``-fexperimental-library`` anymore
- P2674R1: A trait for implicit lifetime types (`Github <https://github.com/llvm/llvm-project/issues/105259>`__)
-- P0429R9: A Standard ``flat_map`` is partially implemented and ``flat_map`` is provided (`https://github.com/llvm/llvm-project/issues/105190`__)
+- P0429R9: A Standard ``flat_map`` is partially implemented and ``flat_map`` is provided (`Github<https://github.com/llvm/llvm-project/issues/105190>`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/include/__flat_map/flat_map.h b/libcxx/include/__flat_map/flat_map.h
index 2a21ccacfa0e03..9ca32d5295bd27 100644
--- a/libcxx/include/__flat_map/flat_map.h
+++ b/libcxx/include/__flat_map/flat_map.h
@@ -30,6 +30,7 @@
#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>
More information about the libcxx-commits
mailing list