From Jason Turner

[flat.multimap.defn]

C++23 → Trunk 17.6 KB 275 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp9nwbkcwo/{from.md → to.md} +141 -131
tmp/tmp9nwbkcwo/{from.md → to.md} RENAMED
@@ -23,209 +23,219 @@ namespace std {
23
  using mapped_container_type = MappedContainer;
24
 
25
  class value_compare {
26
  private:
27
  key_compare comp; // exposition only
28
- value_compare(key_compare c) : comp(c) { } // exposition only
29
 
30
  public:
31
- bool operator()(const_reference x, const_reference y) const {
32
  return comp(x.first, y.first);
33
  }
34
  };
35
 
36
  struct containers {
37
  key_container_type keys;
38
  mapped_container_type values;
39
  };
40
 
41
- // [flat.multimap.cons], construct/copy/destroy
42
- flat_multimap() : flat_multimap(key_compare()) { }
43
 
44
- flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
45
- const key_compare& comp = key_compare());
46
- template<class Allocator>
47
- flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
48
- const Allocator& a);
49
- template<class Allocator>
50
- flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
51
- const key_compare& comp, const Allocator& a);
52
-
53
- flat_multimap(sorted_equivalent_t,
54
- key_container_type key_cont, mapped_container_type mapped_cont,
55
- const key_compare& comp = key_compare());
56
- template<class Allocator>
57
- flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
58
- const mapped_container_type& mapped_cont, const Allocator& a);
59
- template<class Allocator>
60
- flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
61
- const mapped_container_type& mapped_cont,
62
- const key_compare& comp, const Allocator& a);
63
-
64
- explicit flat_multimap(const key_compare& comp)
65
  : c(), compare(comp) { }
66
- template<class Allocator>
67
- flat_multimap(const key_compare& comp, const Allocator& a);
68
- template<class Allocator>
69
- explicit flat_multimap(const Allocator& a);
 
 
 
70
 
71
  template<class InputIterator>
72
- flat_multimap(InputIterator first, InputIterator last,
73
  const key_compare& comp = key_compare())
74
  : c(), compare(comp)
75
  { insert(first, last); }
76
- template<class InputIterator, class Allocator>
77
- flat_multimap(InputIterator first, InputIterator last,
78
- const key_compare& comp, const Allocator& a);
79
- template<class InputIterator, class Allocator>
80
- flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
81
 
82
  template<container-compatible-range<value_type> R>
83
- flat_multimap(from_range_t fr, R&& rg)
84
- : flat_multimap(fr, std::forward<R>(rg), key_compare()) { }
85
- template<container-compatible-range<value_type> R, class Allocator>
86
- flat_multimap(from_range_t, R&& rg, const Allocator& a);
87
  template<container-compatible-range<value_type> R>
88
- flat_multimap(from_range_t, R&& rg, const key_compare& comp)
89
  : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
90
- template<container-compatible-range<value_type> R, class Allocator>
91
- flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
92
 
93
- template<class InputIterator>
94
- flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
95
  const key_compare& comp = key_compare())
96
- : c(), compare(comp) { insert(s, first, last); }
97
- template<class InputIterator, class Allocator>
98
- flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
99
- const key_compare& comp, const Allocator& a);
100
- template<class InputIterator, class Allocator>
101
- flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
102
- const Allocator& a);
103
-
104
- flat_multimap(initializer_list<value_type> il, const key_compare& comp = key_compare())
105
  : flat_multimap(il.begin(), il.end(), comp) { }
106
- template<class Allocator>
107
- flat_multimap(initializer_list<value_type> il, const key_compare& comp,
108
- const Allocator& a);
109
- template<class Allocator>
110
- flat_multimap(initializer_list<value_type> il, const Allocator& a);
111
 
112
- flat_multimap(sorted_equivalent_t s, initializer_list<value_type> il,
113
  const key_compare& comp = key_compare())
114
- : flat_multimap(s, il.begin(), il.end(), comp) { }
115
- template<class Allocator>
116
- flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
117
- const key_compare& comp, const Allocator& a);
118
- template<class Allocator>
119
- flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
120
 
121
- flat_multimap& operator=(initializer_list<value_type> il);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
122
 
123
  // iterators
124
- iterator begin() noexcept;
125
- const_iterator begin() const noexcept;
126
- iterator end() noexcept;
127
- const_iterator end() const noexcept;
128
 
129
- reverse_iterator rbegin() noexcept;
130
- const_reverse_iterator rbegin() const noexcept;
131
- reverse_iterator rend() noexcept;
132
- const_reverse_iterator rend() const noexcept;
133
 
134
- const_iterator cbegin() const noexcept;
135
- const_iterator cend() const noexcept;
136
- const_reverse_iterator crbegin() const noexcept;
137
- const_reverse_iterator crend() const noexcept;
138
 
139
  // capacity
140
- [[nodiscard]] bool empty() const noexcept;
141
- size_type size() const noexcept;
142
- size_type max_size() const noexcept;
143
 
144
  // modifiers
145
- template<class... Args> iterator emplace(Args&&... args);
146
  template<class... Args>
147
- iterator emplace_hint(const_iterator position, Args&&... args);
148
 
149
- iterator insert(const value_type& x)
150
  { return emplace(x); }
151
- iterator insert(value_type&& x)
152
  { return emplace(std::move(x)); }
153
- iterator insert(const_iterator position, const value_type& x)
154
  { return emplace_hint(position, x); }
155
- iterator insert(const_iterator position, value_type&& x)
156
  { return emplace_hint(position, std::move(x)); }
157
 
158
- template<class P> iterator insert(P&& x);
159
  template<class P>
160
- iterator insert(const_iterator position, P&&);
161
  template<class InputIterator>
162
- void insert(InputIterator first, InputIterator last);
163
  template<class InputIterator>
164
- void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
165
  template<container-compatible-range<value_type> R>
166
- void insert_range(R&& rg);
167
 
168
- void insert(initializer_list<value_type> il)
169
  { insert(il.begin(), il.end()); }
170
- void insert(sorted_equivalent_t s, initializer_list<value_type> il)
171
- { insert(s, il.begin(), il.end()); }
172
 
173
- containers extract() &&;
174
- void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
175
 
176
- iterator erase(iterator position);
177
- iterator erase(const_iterator position);
178
- size_type erase(const key_type& x);
179
- template<class K> size_type erase(K&& x);
180
- iterator erase(const_iterator first, const_iterator last);
181
 
182
- void swap(flat_multimap&) noexcept;
183
- void clear() noexcept;
184
 
185
  // observers
186
- key_compare key_comp() const;
187
- value_compare value_comp() const;
188
 
189
- const key_container_type& keys() const noexcept { return c.keys; }
190
- const mapped_container_type& values() const noexcept { return c.values; }
191
 
192
  // map operations
193
- iterator find(const key_type& x);
194
- const_iterator find(const key_type& x) const;
195
- template<class K> iterator find(const K& x);
196
- template<class K> const_iterator find(const K& x) const;
197
 
198
- size_type count(const key_type& x) const;
199
- template<class K> size_type count(const K& x) const;
200
 
201
- bool contains(const key_type& x) const;
202
- template<class K> bool contains(const K& x) const;
203
 
204
- iterator lower_bound(const key_type& x);
205
- const_iterator lower_bound(const key_type& x) const;
206
- template<class K> iterator lower_bound(const K& x);
207
- template<class K> const_iterator lower_bound(const K& x) const;
208
 
209
- iterator upper_bound(const key_type& x);
210
- const_iterator upper_bound(const key_type& x) const;
211
- template<class K> iterator upper_bound(const K& x);
212
- template<class K> const_iterator upper_bound(const K& x) const;
213
 
214
- pair<iterator, iterator> equal_range(const key_type& x);
215
- pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
216
  template<class K>
217
- pair<iterator, iterator> equal_range(const K& x);
218
  template<class K>
219
- pair<const_iterator, const_iterator> equal_range(const K& x) const;
220
 
221
- friend bool operator==(const flat_multimap& x, const flat_multimap& y);
222
 
223
- friend synth-three-way-result<value_type>
224
  operator<=>(const flat_multimap& x, const flat_multimap& y);
225
 
226
- friend void swap(flat_multimap& x, flat_multimap& y) noexcept
227
  { x.swap(y); }
228
 
229
  private:
230
  containers c; // exposition only
231
  key_compare compare; // exposition only
 
23
  using mapped_container_type = MappedContainer;
24
 
25
  class value_compare {
26
  private:
27
  key_compare comp; // exposition only
28
+ constexpr value_compare(key_compare c) : comp(c) { } // exposition only
29
 
30
  public:
31
+ constexpr bool operator()(const_reference x, const_reference y) const {
32
  return comp(x.first, y.first);
33
  }
34
  };
35
 
36
  struct containers {
37
  key_container_type keys;
38
  mapped_container_type values;
39
  };
40
 
41
+ // [flat.multimap.cons], constructors
42
+ constexpr flat_multimap() : flat_multimap(key_compare()) { }
43
 
44
+ constexpr explicit flat_multimap(const key_compare& comp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
45
  : c(), compare(comp) { }
46
+
47
+ constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
48
+ const key_compare& comp = key_compare());
49
+
50
+ constexpr flat_multimap(sorted_equivalent_t,
51
+ key_container_type key_cont, mapped_container_type mapped_cont,
52
+ const key_compare& comp = key_compare());
53
 
54
  template<class InputIterator>
55
+ constexpr flat_multimap(InputIterator first, InputIterator last,
56
  const key_compare& comp = key_compare())
57
  : c(), compare(comp)
58
  { insert(first, last); }
59
+
60
+ template<class InputIterator>
61
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
62
+ const key_compare& comp = key_compare())
63
+ : c(), compare(comp) { insert(sorted_equivalent, first, last); }
64
 
65
  template<container-compatible-range<value_type> R>
66
+ constexpr flat_multimap(from_range_t, R&& rg)
67
+ : flat_multimap(from_range, std::forward<R>(rg), key_compare()) { }
 
 
68
  template<container-compatible-range<value_type> R>
69
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp)
70
  : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
 
 
71
 
72
+ constexpr flat_multimap(initializer_list<value_type> il,
 
73
  const key_compare& comp = key_compare())
 
 
 
 
 
 
 
 
 
74
  : flat_multimap(il.begin(), il.end(), comp) { }
 
 
 
 
 
75
 
76
+ constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
77
  const key_compare& comp = key_compare())
78
+ : flat_multimap(sorted_equivalent, il.begin(), il.end(), comp) { }
 
 
 
 
 
79
 
80
+ // [flat.multimap.cons.alloc], constructors with allocators
81
+
82
+ template<class Alloc>
83
+ constexpr explicit flat_multimap(const Alloc& a);
84
+ template<class Alloc>
85
+ constexpr flat_multimap(const key_compare& comp, const Alloc& a);
86
+ template<class Alloc>
87
+ constexpr flat_multimap(const key_container_type& key_cont,
88
+ const mapped_container_type& mapped_cont, const Alloc& a);
89
+ template<class Alloc>
90
+ constexpr flat_multimap(const key_container_type& key_cont,
91
+ const mapped_container_type& mapped_cont,
92
+ const key_compare& comp, const Alloc& a);
93
+ template<class Alloc>
94
+ constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
95
+ const mapped_container_type& mapped_cont, const Alloc& a);
96
+ template<class Alloc>
97
+ constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
98
+ const mapped_container_type& mapped_cont,
99
+ const key_compare& comp, const Alloc& a);
100
+ template<class Alloc>
101
+ constexpr flat_multimap(const flat_multimap&, const Alloc& a);
102
+ template<class Alloc>
103
+ constexpr flat_multimap(flat_multimap&&, const Alloc& a);
104
+ template<class InputIterator, class Alloc>
105
+ constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
106
+ template<class InputIterator, class Alloc>
107
+ constexpr flat_multimap(InputIterator first, InputIterator last,
108
+ const key_compare& comp, const Alloc& a);
109
+ template<class InputIterator, class Alloc>
110
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
111
+ const Alloc& a);
112
+ template<class InputIterator, class Alloc>
113
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
114
+ const key_compare& comp, const Alloc& a);
115
+ template<container-compatible-range<value_type> R, class Alloc>
116
+ constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
117
+ template<container-compatible-range<value_type> R, class Alloc>
118
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
119
+ template<class Alloc>
120
+ constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
121
+ template<class Alloc>
122
+ constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
123
+ const Alloc& a);
124
+ template<class Alloc>
125
+ constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
126
+ const Alloc& a);
127
+ template<class Alloc>
128
+ constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
129
+ const key_compare& comp, const Alloc& a);
130
+
131
+ flat_multimap& operator=(initializer_list<value_type>);
132
 
133
  // iterators
134
+ constexpr iterator begin() noexcept;
135
+ constexpr const_iterator begin() const noexcept;
136
+ constexpr iterator end() noexcept;
137
+ constexpr const_iterator end() const noexcept;
138
 
139
+ constexpr reverse_iterator rbegin() noexcept;
140
+ constexpr const_reverse_iterator rbegin() const noexcept;
141
+ constexpr reverse_iterator rend() noexcept;
142
+ constexpr const_reverse_iterator rend() const noexcept;
143
 
144
+ constexpr const_iterator cbegin() const noexcept;
145
+ constexpr const_iterator cend() const noexcept;
146
+ constexpr const_reverse_iterator crbegin() const noexcept;
147
+ constexpr const_reverse_iterator crend() const noexcept;
148
 
149
  // capacity
150
+ constexpr bool empty() const noexcept;
151
+ constexpr size_type size() const noexcept;
152
+ constexpr size_type max_size() const noexcept;
153
 
154
  // modifiers
155
+ template<class... Args> constexpr iterator emplace(Args&&... args);
156
  template<class... Args>
157
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
158
 
159
+ constexpr iterator insert(const value_type& x)
160
  { return emplace(x); }
161
+ constexpr iterator insert(value_type&& x)
162
  { return emplace(std::move(x)); }
163
+ constexpr iterator insert(const_iterator position, const value_type& x)
164
  { return emplace_hint(position, x); }
165
+ constexpr iterator insert(const_iterator position, value_type&& x)
166
  { return emplace_hint(position, std::move(x)); }
167
 
168
+ template<class P> constexpr iterator insert(P&& x);
169
  template<class P>
170
+ constexpr iterator insert(const_iterator position, P&&);
171
  template<class InputIterator>
172
+ constexpr void insert(InputIterator first, InputIterator last);
173
  template<class InputIterator>
174
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
175
  template<container-compatible-range<value_type> R>
176
+ constexpr void insert_range(R&& rg);
177
 
178
+ constexpr void insert(initializer_list<value_type> il)
179
  { insert(il.begin(), il.end()); }
180
+ constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
181
+ { insert(sorted_equivalent, il.begin(), il.end()); }
182
 
183
+ constexpr containers extract() &&;
184
+ constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
185
 
186
+ constexpr iterator erase(iterator position);
187
+ constexpr iterator erase(const_iterator position);
188
+ constexpr size_type erase(const key_type& x);
189
+ template<class K> constexpr size_type erase(K&& x);
190
+ constexpr iterator erase(const_iterator first, const_iterator last);
191
 
192
+ constexpr void swap(flat_multimap&) noexcept;
193
+ constexpr void clear() noexcept;
194
 
195
  // observers
196
+ constexpr key_compare key_comp() const;
197
+ constexpr value_compare value_comp() const;
198
 
199
+ constexpr const key_container_type& keys() const noexcept { return c.keys; }
200
+ constexpr const mapped_container_type& values() const noexcept { return c.values; }
201
 
202
  // map operations
203
+ constexpr iterator find(const key_type& x);
204
+ constexpr const_iterator find(const key_type& x) const;
205
+ template<class K> constexpr iterator find(const K& x);
206
+ template<class K> constexpr const_iterator find(const K& x) const;
207
 
208
+ constexpr size_type count(const key_type& x) const;
209
+ template<class K> constexpr size_type count(const K& x) const;
210
 
211
+ constexpr bool contains(const key_type& x) const;
212
+ template<class K> constexpr bool contains(const K& x) const;
213
 
214
+ constexpr iterator lower_bound(const key_type& x);
215
+ constexpr const_iterator lower_bound(const key_type& x) const;
216
+ template<class K> constexpr iterator lower_bound(const K& x);
217
+ template<class K> constexpr const_iterator lower_bound(const K& x) const;
218
 
219
+ constexpr iterator upper_bound(const key_type& x);
220
+ constexpr const_iterator upper_bound(const key_type& x) const;
221
+ template<class K> constexpr iterator upper_bound(const K& x);
222
+ template<class K> constexpr const_iterator upper_bound(const K& x) const;
223
 
224
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
225
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
226
  template<class K>
227
+ constexpr pair<iterator, iterator> equal_range(const K& x);
228
  template<class K>
229
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
230
 
231
+ friend constexpr bool operator==(const flat_multimap& x, const flat_multimap& y);
232
 
233
+ friend constexpr synth-three-way-result<value_type>
234
  operator<=>(const flat_multimap& x, const flat_multimap& y);
235
 
236
+ friend constexpr void swap(flat_multimap& x, flat_multimap& y) noexcept
237
  { x.swap(y); }
238
 
239
  private:
240
  containers c; // exposition only
241
  key_compare compare; // exposition only