|
173
|
1 // -*- C++ -*-
|
|
|
2 //===-------------------------- concepts ----------------------------------===//
|
|
|
3 //
|
|
|
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
5 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
7 //
|
|
|
8 //===----------------------------------------------------------------------===//
|
|
|
9
|
|
|
10 #ifndef _LIBCPP_CONCEPTS
|
|
|
11 #define _LIBCPP_CONCEPTS
|
|
|
12
|
|
|
13 /*
|
|
|
14 concepts synopsis
|
|
|
15 namespace std {
|
|
|
16 // [concepts.lang], language-related concepts
|
|
|
17 // [concept.same], concept same_as
|
|
|
18 template<class T, class U>
|
|
|
19 concept same_as = see below;
|
|
|
20
|
|
|
21 // [concept.derived], concept derived_from
|
|
|
22 template<class Derived, class Base>
|
|
|
23 concept derived_from = see below;
|
|
|
24
|
|
|
25 // [concept.convertible], concept convertible_to
|
|
|
26 template<class From, class To>
|
|
|
27 concept convertible_to = see below;
|
|
|
28
|
|
|
29 // [concept.commonref], concept common_reference_with
|
|
|
30 template<class T, class U>
|
|
|
31 concept common_reference_with = see below;
|
|
|
32
|
|
|
33 // [concept.common], concept common_with
|
|
|
34 template<class T, class U>
|
|
|
35 concept common_with = see below;
|
|
|
36
|
|
|
37 // [concepts.arithmetic], arithmetic concepts
|
|
|
38 template<class T>
|
|
|
39 concept integral = see below;
|
|
|
40 template<class T>
|
|
|
41 concept signed_integral = see below;
|
|
|
42 template<class T>
|
|
|
43 concept unsigned_integral = see below;
|
|
|
44 template<class T>
|
|
|
45 concept floating_point = see below;
|
|
|
46
|
|
|
47 // [concept.assignable], concept assignable_from
|
|
|
48 template<class LHS, class RHS>
|
|
|
49 concept assignable_from = see below;
|
|
|
50
|
|
|
51 // [concept.swappable], concept swappable
|
|
|
52 namespace ranges {
|
|
|
53 inline namespace unspecified {
|
|
|
54 inline constexpr unspecified swap = unspecified;
|
|
|
55 }
|
|
|
56 }
|
|
|
57 template<class T>
|
|
|
58 concept swappable = see below;
|
|
|
59 template<class T, class U>
|
|
|
60 concept swappable_with = see below;
|
|
|
61
|
|
|
62 // [concept.destructible], concept destructible
|
|
|
63 template<class T>
|
|
|
64 concept destructible = see below;
|
|
|
65
|
|
|
66 // [concept.constructible], concept constructible_from
|
|
|
67 template<class T, class... Args>
|
|
|
68 concept constructible_from = see below;
|
|
|
69
|
|
221
|
70 // [concept.default.init], concept default_initializable
|
|
173
|
71 template<class T>
|
|
221
|
72 concept default_initializable = see below;
|
|
173
|
73
|
|
|
74 // [concept.moveconstructible], concept move_constructible
|
|
|
75 template<class T>
|
|
|
76 concept move_constructible = see below;
|
|
|
77
|
|
|
78 // [concept.copyconstructible], concept copy_constructible
|
|
|
79 template<class T>
|
|
|
80 concept copy_constructible = see below;
|
|
|
81
|
|
|
82 // [concept.equalitycomparable], concept equality_comparable
|
|
|
83 template<class T>
|
|
|
84 concept equality_comparable = see below;
|
|
|
85 template<class T, class U>
|
|
|
86 concept equality_comparable_with = see below;
|
|
|
87
|
|
|
88 // [concept.totallyordered], concept totally_ordered
|
|
|
89 template<class T>
|
|
|
90 concept totally_ordered = see below;
|
|
|
91 template<class T, class U>
|
|
|
92 concept totally_ordered_with = see below;
|
|
|
93
|
|
|
94 // [concepts.object], object concepts
|
|
|
95 template<class T>
|
|
|
96 concept movable = see below;
|
|
|
97 template<class T>
|
|
|
98 concept copyable = see below;
|
|
|
99 template<class T>
|
|
|
100 concept semiregular = see below;
|
|
|
101 template<class T>
|
|
|
102 concept regular = see below;
|
|
|
103
|
|
|
104 // [concepts.callable], callable concepts
|
|
|
105 // [concept.invocable], concept invocable
|
|
|
106 template<class F, class... Args>
|
|
|
107 concept invocable = see below;
|
|
|
108
|
|
|
109 // [concept.regularinvocable], concept regular_invocable
|
|
|
110 template<class F, class... Args>
|
|
|
111 concept regular_invocable = see below;
|
|
|
112
|
|
|
113 // [concept.predicate], concept predicate
|
|
|
114 template<class F, class... Args>
|
|
|
115 concept predicate = see below;
|
|
|
116
|
|
|
117 // [concept.relation], concept relation
|
|
|
118 template<class R, class T, class U>
|
|
|
119 concept relation = see below;
|
|
|
120
|
|
|
121 // [concept.equiv], concept equivalence_relation
|
|
|
122 template<class R, class T, class U>
|
|
|
123 concept equivalence_relation = see below;
|
|
|
124
|
|
|
125 // [concept.strictweakorder], concept strict_weak_order
|
|
|
126 template<class R, class T, class U>
|
|
|
127 concept strict_weak_order = see below;
|
|
|
128 }
|
|
|
129
|
|
|
130 */
|
|
|
131
|
|
|
132 #include <__config>
|
|
223
|
133 #include <__functional/invoke.h>
|
|
221
|
134 #include <__functional_base>
|
|
173
|
135 #include <type_traits>
|
|
221
|
136 #include <utility>
|
|
173
|
137 #include <version>
|
|
|
138
|
|
|
139 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
|
140 #pragma GCC system_header
|
|
|
141 #endif
|
|
|
142
|
|
|
143 _LIBCPP_PUSH_MACROS
|
|
|
144 #include <__undef_macros>
|
|
|
145
|
|
|
146 _LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
147
|
|
221
|
148 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
|
|
173
|
149
|
|
|
150 // [concept.same]
|
|
|
151
|
|
|
152 template<class _Tp, class _Up>
|
|
|
153 concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
|
|
|
154
|
|
|
155 template<class _Tp, class _Up>
|
|
|
156 concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
|
|
|
157
|
|
221
|
158 // [concept.derived]
|
|
|
159 template<class _Dp, class _Bp>
|
|
|
160 concept derived_from =
|
|
|
161 is_base_of_v<_Bp, _Dp> &&
|
|
|
162 is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
|
|
|
163
|
|
|
164 // [concept.convertible]
|
|
|
165 template<class _From, class _To>
|
|
|
166 concept convertible_to =
|
|
|
167 is_convertible_v<_From, _To> &&
|
|
|
168 requires(add_rvalue_reference_t<_From> (&__f)()) {
|
|
|
169 static_cast<_To>(__f());
|
|
|
170 };
|
|
|
171
|
|
|
172 // [concept.commonref]
|
|
|
173 template<class _Tp, class _Up>
|
|
|
174 concept common_reference_with =
|
|
|
175 same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
|
|
|
176 convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
|
|
|
177 convertible_to<_Up, common_reference_t<_Tp, _Up>>;
|
|
|
178
|
|
|
179 // [concept.common]
|
|
|
180 template<class _Tp, class _Up>
|
|
|
181 concept common_with =
|
|
|
182 same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
|
|
|
183 requires {
|
|
|
184 static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
|
|
|
185 static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
|
|
|
186 } &&
|
|
|
187 common_reference_with<
|
|
|
188 add_lvalue_reference_t<const _Tp>,
|
|
|
189 add_lvalue_reference_t<const _Up>> &&
|
|
|
190 common_reference_with<
|
|
|
191 add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
|
|
|
192 common_reference_t<
|
|
|
193 add_lvalue_reference_t<const _Tp>,
|
|
|
194 add_lvalue_reference_t<const _Up>>>;
|
|
|
195
|
|
|
196 // [concepts.arithmetic], arithmetic concepts
|
|
|
197 template<class _Tp>
|
|
|
198 concept integral = is_integral_v<_Tp>;
|
|
|
199
|
|
|
200 template<class _Tp>
|
|
|
201 concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
|
|
|
202
|
|
|
203 template<class _Tp>
|
|
|
204 concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
|
|
|
205
|
|
|
206 template<class _Tp>
|
|
|
207 concept floating_point = is_floating_point_v<_Tp>;
|
|
|
208
|
|
|
209 // [concept.assignable]
|
|
|
210 template<class _Lhs, class _Rhs>
|
|
|
211 concept assignable_from =
|
|
|
212 is_lvalue_reference_v<_Lhs> &&
|
|
|
213 common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
|
|
|
214 requires (_Lhs __lhs, _Rhs&& __rhs) {
|
|
|
215 { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
|
|
|
216 };
|
|
|
217
|
|
|
218 // [concept.destructible]
|
|
|
219
|
|
|
220 template<class _Tp>
|
|
|
221 concept destructible = is_nothrow_destructible_v<_Tp>;
|
|
|
222
|
|
|
223 // [concept.constructible]
|
|
|
224 template<class _Tp, class... _Args>
|
|
|
225 concept constructible_from =
|
|
|
226 destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
|
|
|
227
|
|
|
228 // [concept.default.init]
|
|
|
229
|
|
|
230 template<class _Tp>
|
|
|
231 concept __default_initializable = requires { ::new _Tp; };
|
|
|
232
|
|
|
233 template<class _Tp>
|
|
|
234 concept default_initializable = constructible_from<_Tp> &&
|
|
|
235 requires { _Tp{}; } && __default_initializable<_Tp>;
|
|
|
236
|
|
|
237 // [concept.moveconstructible]
|
|
|
238 template<class _Tp>
|
|
|
239 concept move_constructible =
|
|
|
240 constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
|
|
|
241
|
|
|
242 // [concept.copyconstructible]
|
|
|
243 template<class _Tp>
|
|
|
244 concept copy_constructible =
|
|
|
245 move_constructible<_Tp> &&
|
|
|
246 constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
|
|
|
247 constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
|
|
|
248 constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
|
|
|
249
|
|
|
250 // Whether a type is a class type or enumeration type according to the Core wording.
|
|
|
251 template<class _Tp>
|
|
|
252 concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
|
|
|
253
|
|
|
254 // [concept.swappable]
|
|
|
255 namespace ranges::__swap {
|
|
|
256 // Deleted to inhibit ADL
|
|
|
257 template<class _Tp>
|
|
|
258 void swap(_Tp&, _Tp&) = delete;
|
|
|
259
|
|
|
260
|
|
|
261 // [1]
|
|
|
262 template<class _Tp, class _Up>
|
|
|
263 concept __unqualified_swappable_with =
|
|
|
264 (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
|
|
|
265 requires(_Tp&& __t, _Up&& __u) {
|
|
|
266 swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
|
|
|
267 };
|
|
|
268
|
|
|
269 struct __fn;
|
|
|
270
|
|
|
271 template<class _Tp, class _Up, size_t _Size>
|
|
|
272 concept __swappable_arrays =
|
|
|
273 !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
|
|
|
274 extent_v<_Tp> == extent_v<_Up> &&
|
|
|
275 requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
|
|
|
276 __swap(__t[0], __u[0]);
|
|
|
277 };
|
|
|
278
|
|
|
279 template<class _Tp>
|
|
|
280 concept __exchangeable =
|
|
|
281 !__unqualified_swappable_with<_Tp&, _Tp&> &&
|
|
|
282 move_constructible<_Tp> &&
|
|
|
283 assignable_from<_Tp&, _Tp>;
|
|
|
284
|
|
|
285 struct __fn {
|
|
|
286 // 2.1 `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
|
|
|
287 // *The name `swap` is used here unqualified.
|
|
|
288 template<class _Tp, class _Up>
|
|
|
289 requires __unqualified_swappable_with<_Tp, _Up>
|
|
|
290 constexpr void operator()(_Tp&& __t, _Up&& __u) const
|
|
|
291 noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
|
|
|
292 {
|
|
|
293 swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
|
|
|
294 }
|
|
|
295
|
|
|
296 // 2.2 Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
|
|
|
297 template<class _Tp, class _Up, size_t _Size>
|
|
|
298 requires __swappable_arrays<_Tp, _Up, _Size>
|
|
|
299 constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
|
|
|
300 noexcept(noexcept((*this)(*__t, *__u)))
|
|
|
301 {
|
|
|
302 // TODO(cjdb): replace with `ranges::swap_ranges`.
|
|
|
303 for (size_t __i = 0; __i < _Size; ++__i) {
|
|
|
304 (*this)(__t[__i], __u[__i]);
|
|
|
305 }
|
|
|
306 }
|
|
|
307
|
|
|
308 // 2.3 Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
|
|
|
309 template<__exchangeable _Tp>
|
|
|
310 constexpr void operator()(_Tp& __x, _Tp& __y) const
|
|
|
311 noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
|
|
|
312 {
|
|
|
313 __y = _VSTD::exchange(__x, _VSTD::move(__y));
|
|
|
314 }
|
|
|
315 };
|
|
|
316 } // namespace ranges::__swap
|
|
|
317
|
|
|
318 namespace ranges::inline __cpo {
|
|
|
319 inline constexpr auto swap = __swap::__fn{};
|
|
|
320 } // namespace ranges::__cpo
|
|
|
321
|
|
|
322 template<class _Tp>
|
|
|
323 concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
|
|
|
324
|
|
|
325 template<class _Tp, class _Up>
|
|
|
326 concept swappable_with =
|
|
|
327 common_reference_with<_Tp, _Up> &&
|
|
|
328 requires(_Tp&& __t, _Up&& __u) {
|
|
|
329 ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
|
|
|
330 ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
|
|
|
331 ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
|
|
|
332 ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
|
|
|
333 };
|
|
|
334
|
|
|
335 // [concept.booleantestable]
|
|
|
336 template<class _Tp>
|
|
|
337 concept __boolean_testable_impl = convertible_to<_Tp, bool>;
|
|
|
338
|
|
|
339 template<class _Tp>
|
|
|
340 concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
|
|
|
341 { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
|
|
|
342 };
|
|
|
343
|
|
|
344 // [concept.equalitycomparable]
|
|
|
345 template<class _Tp, class _Up>
|
|
|
346 concept __weakly_equality_comparable_with =
|
|
|
347 requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
|
|
|
348 { __t == __u } -> __boolean_testable;
|
|
|
349 { __t != __u } -> __boolean_testable;
|
|
|
350 { __u == __t } -> __boolean_testable;
|
|
|
351 { __u != __t } -> __boolean_testable;
|
|
|
352 };
|
|
|
353
|
|
|
354 template<class _Tp>
|
|
|
355 concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
|
|
|
356
|
|
|
357 template<class _Tp, class _Up>
|
|
|
358 concept equality_comparable_with =
|
|
|
359 equality_comparable<_Tp> && equality_comparable<_Up> &&
|
|
|
360 common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
|
|
|
361 equality_comparable<
|
|
|
362 common_reference_t<
|
|
|
363 __make_const_lvalue_ref<_Tp>,
|
|
|
364 __make_const_lvalue_ref<_Up>>> &&
|
|
|
365 __weakly_equality_comparable_with<_Tp, _Up>;
|
|
|
366
|
|
|
367 // [concept.totallyordered]
|
|
|
368
|
|
|
369 template<class _Tp, class _Up>
|
|
|
370 concept __partially_ordered_with =
|
|
|
371 requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
|
|
|
372 { __t < __u } -> __boolean_testable;
|
|
|
373 { __t > __u } -> __boolean_testable;
|
|
|
374 { __t <= __u } -> __boolean_testable;
|
|
|
375 { __t >= __u } -> __boolean_testable;
|
|
|
376 { __u < __t } -> __boolean_testable;
|
|
|
377 { __u > __t } -> __boolean_testable;
|
|
|
378 { __u <= __t } -> __boolean_testable;
|
|
|
379 { __u >= __t } -> __boolean_testable;
|
|
|
380 };
|
|
|
381
|
|
|
382 template<class _Tp>
|
|
|
383 concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
|
|
|
384
|
|
|
385 template<class _Tp, class _Up>
|
|
|
386 concept totally_ordered_with =
|
|
|
387 totally_ordered<_Tp> && totally_ordered<_Up> &&
|
|
|
388 equality_comparable_with<_Tp, _Up> &&
|
|
|
389 totally_ordered<
|
|
|
390 common_reference_t<
|
|
|
391 __make_const_lvalue_ref<_Tp>,
|
|
|
392 __make_const_lvalue_ref<_Up>>> &&
|
|
|
393 __partially_ordered_with<_Tp, _Up>;
|
|
|
394
|
|
|
395 // [concepts.object]
|
|
|
396 template<class _Tp>
|
|
|
397 concept movable =
|
|
|
398 is_object_v<_Tp> &&
|
|
|
399 move_constructible<_Tp> &&
|
|
|
400 assignable_from<_Tp&, _Tp> &&
|
|
|
401 swappable<_Tp>;
|
|
|
402
|
|
|
403 template<class _Tp>
|
|
|
404 concept copyable =
|
|
|
405 copy_constructible<_Tp> &&
|
|
|
406 movable<_Tp> &&
|
|
|
407 assignable_from<_Tp&, _Tp&> &&
|
|
|
408 assignable_from<_Tp&, const _Tp&> &&
|
|
|
409 assignable_from<_Tp&, const _Tp>;
|
|
|
410
|
|
|
411 template<class _Tp>
|
|
|
412 concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
|
|
|
413
|
|
|
414 template<class _Tp>
|
|
|
415 concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
|
|
|
416
|
|
|
417 // [concept.invocable]
|
|
|
418 template<class _Fn, class... _Args>
|
|
|
419 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
|
|
|
420 _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
|
|
|
421 };
|
|
|
422
|
|
|
423 // [concept.regular.invocable]
|
|
|
424 template<class _Fn, class... _Args>
|
|
|
425 concept regular_invocable = invocable<_Fn, _Args...>;
|
|
|
426
|
|
|
427 // [concept.predicate]
|
|
|
428 template<class _Fn, class... _Args>
|
|
|
429 concept predicate =
|
|
|
430 regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
|
|
|
431
|
|
|
432 // [concept.relation]
|
|
|
433 template<class _Rp, class _Tp, class _Up>
|
|
|
434 concept relation =
|
|
|
435 predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
|
|
|
436 predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
|
|
|
437
|
|
|
438 // [concept.equiv]
|
|
|
439 template<class _Rp, class _Tp, class _Up>
|
|
|
440 concept equivalence_relation = relation<_Rp, _Tp, _Up>;
|
|
|
441
|
|
|
442 // [concept.strictweakorder]
|
|
|
443 template<class _Rp, class _Tp, class _Up>
|
|
|
444 concept strict_weak_order = relation<_Rp, _Tp, _Up>;
|
|
|
445
|
|
|
446 template<class _Tp, class _Up>
|
|
|
447 concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
|
|
|
448
|
|
|
449 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
|
|
173
|
450
|
|
|
451 _LIBCPP_END_NAMESPACE_STD
|
|
|
452
|
|
|
453 _LIBCPP_POP_MACROS
|
|
|
454
|
|
|
455 #endif // _LIBCPP_CONCEPTS
|
