Qx v0.5.8
Qt Extensions Library
Loading...
Searching...
No Matches
qx-concepts.h
Go to the documentation of this file.
1#ifndef QX_CONCEPTS_H
2#define QX_CONCEPTS_H
3
4// Standard Library Includes
5#include <utility>
6#include <iterator>
7#include <type_traits>
8
9// Qt Includes
10#include <QHash>
11#include <QMap>
12
14namespace QxConceptsPrivate
15{
16
17template <class A, template <typename...> class B>
18struct is_specialization_of : std::false_type {};
19
20template <typename... Args, template <typename...> class B>
21struct is_specialization_of<B<Args...>, B> : std::true_type {};
22
23template <typename A, template <typename...> class B>
24inline constexpr bool is_specialization_of_v = is_specialization_of<A, B>::value;
25
26}
29namespace Qx
30{
31
32// Assignment Operators
33template<class K, typename T>
34concept defines_assign_for_s = requires(K klass, T type) {{ klass = type } -> std::same_as<K&>;};
35
36template<class K, typename T>
37concept defines_assign_for = requires(K klass, T type) {{ klass = type };};
38
39template<class K>
40concept defines_assign_s = defines_assign_for_s<K, K>;
41
42template<class K>
43concept defines_assign = defines_assign_for<K, K>;
44
45template<class K, typename T>
46concept defines_add_assign_for_s = requires(K klass, T type) {{ klass += type } -> std::same_as<K&>;};
47
48template<class K, typename T>
49concept defines_add_assign_for = requires(K klass, T type) {{ klass += type };};
50
51template<class K>
52concept defines_add_assign_s = defines_add_assign_for_s<K, K>;
53
54template<class K>
55concept defines_add_assign = defines_add_assign_for<K, K>;
56
57template<class K, typename T>
58concept defines_sub_assign_for_s = requires(K klass, T type) {{ klass -= type } -> std::same_as<K&>;};
59
60template<class K, typename T>
61concept defines_sub_assign_for = requires(K klass, T type) {{ klass -= type };};
62
63template<class K>
64concept defines_sub_assign_s = defines_sub_assign_for_s<K, K>;
65
66template<class K>
67concept defines_sub_assign = defines_sub_assign_for<K, K>;
68
69template<class K, typename T>
70concept defines_mult_assign_for_s = requires(K klass, T type) {{ klass *= type } -> std::same_as<K&>;};
71
72template<class K, typename T>
73concept defines_mult_assign_for = requires(K klass, T type) {{ klass *= type };};
74
75template<class K>
76concept defines_mult_assign_s = defines_mult_assign_for_s<K, K>;
77
78template<class K>
79concept defines_mult_assign = defines_mult_assign_for<K, K>;
80
81template<class K, typename T>
82concept defines_div_assign_for_s = requires(K klass, T type) {{ klass /= type } -> std::same_as<K&>;};
83
84template<class K, typename T>
85concept defines_div_assign_for = requires(K klass, T type) {{ klass /= type };};
86
87template<class K>
88concept defines_div_assign_s = defines_div_assign_for_s<K, K>;
89
90template<class K>
91concept defines_div_assign = defines_div_assign_for<K, K>;
92
93template<class K, typename T>
94concept defines_mod_assign_for_s = requires(K klass, T type) {{ klass %= type } -> std::same_as<K&>;};
95
96template<class K, typename T>
97concept defines_mod_assign_for = requires(K klass, T type) {{ klass %= type };};
98
99template<class K>
100concept defines_mod_assign_s = defines_mod_assign_for_s<K, K>;
101
102template<class K>
103concept defines_mod_assign = defines_mod_assign_for<K, K>;
104
105template<class K, typename T>
106concept defines_bit_and_assign_for_s = requires(K klass, T type) {{ klass &= type } -> std::same_as<K&>;};
107
108template<class K, typename T>
109concept defines_bit_and_assign_for = requires(K klass, T type) {{ klass &= type };};
110
111template<class K>
112concept defines_bit_and_assign_s = defines_bit_and_assign_for_s<K, K>;
113
114template<class K>
115concept defines_bit_and_assign = defines_bit_and_assign_for<K, K>;
116
117template<class K, typename T>
118concept defines_bit_or_assign_for_s = requires(K klass, T type) {{ klass |= type } -> std::same_as<K&>;};
119
120template<class K, typename T>
121concept defines_bit_or_assign_for = requires(K klass, T type) {{ klass |= type };};
122
123template<class K>
124concept defines_bit_or_assign_s = defines_bit_or_assign_for_s<K, K>;
125
126template<class K>
127concept defines_bit_or_assign = defines_bit_or_assign_for<K, K>;
128
129template<class K, typename T>
130concept defines_bit_xor_assign_for_s = requires(K klass, T type) {{ klass ^= type } -> std::same_as<K&>;};
131
132template<class K, typename T>
133concept defines_bit_xor_assign_for = requires(K klass, T type) {{ klass ^= type };};
134
135template<class K>
136concept defines_bit_xor_assign_s = defines_bit_xor_assign_for_s<K, K>;
137
138template<class K>
139concept defines_bit_xor_assign = defines_bit_xor_assign_for<K, K>;
140
141template<class K, typename T>
142concept defines_left_shift_assign_for_s = requires(K klass, T type) {{ klass <<= type } -> std::same_as<K&>;};
143
144template<class K, typename T>
145concept defines_left_shift_assign_for = requires(K klass, T type) {{ klass <<= type };};
146
147template<class K>
148concept defines_left_shift_assign_s = defines_left_shift_assign_for_s<K, K>;
149
150template<class K>
151concept defines_left_shift_assign = defines_left_shift_assign_for<K, K>;
152
153template<class K, typename T>
154concept defines_right_shift_assign_for_s = requires(K klass, T type) {{ klass >>= type } -> std::same_as<K&>;};
155
156template<class K, typename T>
157concept defines_right_shift_assign_for = requires(K klass, T type) {{ klass >>= type };};
158
159template<class K>
160concept defines_right_shift_assign_s = defines_right_shift_assign_for_s<K, K>;
161
162template<class K>
163concept defines_right_shift_assign = defines_right_shift_assign_for<K, K>;
164
165// Increment Decrement Operators
166template<class K>
167concept defines_pre_increment_s = requires(K klass) {{ ++klass } -> std::same_as<K&>;};
168
169template<class K>
170concept defines_pre_increment = requires(K klass) {{ ++klass };};
171
172template<class K>
173concept defines_pre_decrement_s = requires(K klass) {{ --klass } -> std::same_as<K&>;};
174
175template<class K>
176concept defines_pre_decrement = requires(K klass) {{ --klass };};
177
178template<class K>
179concept defines_post_increment_s = requires(K klass) {{ klass++} -> std::same_as<K>;};
180
181template<class K>
182concept defines_post_increment = requires(K klass) {{ klass++ };};
183
184template<class K>
185concept defines_post_decrement_s = requires(K klass) {{ klass-- } -> std::same_as<K>;};
186
187template<class K>
188concept defines_post_decrement = requires(K klass) {{ klass-- };};
189
190// Logical Operators
191template<class K>
192concept defines_negation_s = requires(K klass) {{ !klass } -> std::same_as<bool>;};
193
194template<class K>
195concept defines_negation = requires(K klass) {{ !klass };};
196
197template<class K, typename T>
198concept defines_and_for_s = requires(K klass, T type) {{ klass && type } -> std::same_as<bool>;};
199
200template<class K, typename T>
201concept defines_and_for = requires(K klass, T type) {{ klass && type };};
202
203template<class K>
204concept defines_and_s = defines_and_for_s<K, K>;
205
206template<class K>
207concept defines_and = defines_and_for<K, K>;
208
209template<class K, typename T>
210concept defines_or_for_s = requires(K klass, T type) {{ klass || type } -> std::same_as<bool>;};
211
212template<class K, typename T>
213concept defines_or_for = requires(K klass, T type) {{ klass || type };};
214
215template<class K>
216concept defines_or_s = defines_or_for_s<K, K>;
217
218template<class K>
219concept defines_or = defines_or_for<K, K>;
220
221// Member Access Operators
222template<class K, typename R, typename T>
223concept defines_subscript_for_s = requires(K klass, T type) {{ klass[type] } -> std::same_as<R&>;};
224
225template<class K, typename T>
226concept defines_subscript_for = requires(K klass, T type) {{ klass[type] };};
227
228template<class K, typename R>
229concept defines_indirection_s = requires(K klass) {{ *klass } -> std::same_as<R&>;};
230
231template<class K>
232concept defines_indirection = requires(K klass) {{ *klass };};
233
234template<class K, typename R>
235concept defines_address_of_s = requires(K klass) {{ &klass } -> std::same_as<R*>;};
236
237template<class K>
238concept defines_address_of = requires(K klass) {{ &klass };};
239
240/* TODO: Not sure how to do this one, there is a "b" parameter but its type could be anything
241 * template<class K, typename R>
242 * concept defines_member_ptr_s = requires(K klass, R ret) {{ klass-> } -> std::same_as<R*>;};
243 */
244
245template<class K, typename R, typename T>
246concept defines_ptr_to_member_ptr_for_s = requires(K klass, T type) {{ klass->*type } -> std::same_as<R&>;};
247
248template<class K, typename T>
249concept defines_ptr_to_member_ptr_for = requires(K klass, T type) {{ klass->*type };};
250
251// Other Operators
252template<class K, typename R, typename... Types>
253concept defines_call_for_s = requires(K klass, Types... args) {{ klass(args...) } -> std::same_as<R>;};
254
255template<class K, typename... Types>
256concept defines_call_for = requires(K klass, Types... args) {{ klass(args...) };};
257
258template<class K, typename R>
259concept defines_call_s = defines_call_for<K, R>;
260
261template<class K>
262concept defines_call = defines_call_for<K>;
263
264template<class K, typename T>
265concept defines_comma_for_s = requires(K klass, T type) {{ klass, type } -> std::same_as<T&>;};
266
267template<class K, typename T>
268concept defines_comma_for = requires(K klass, T type) {{ klass, type };};
269
270
271// Arithmetic Operators
272template<class K>
273concept defines_unary_plus_s = requires(K klass) {{ +klass } -> std::same_as<K>;};
274
275template<class K>
276concept defines_unary_plus = requires(K klass) {{ +klass };};
277
278template<class K>
279concept defines_unary_minus_s = requires(K klass) {{ -klass } -> std::same_as<K>;};
280
281template<class K>
282concept defines_unary_minus = requires(K klass) {{ -klass };};
283
284template<class K, typename T>
285concept defines_add_for_s = requires(K klass, T type) {{ klass + type } -> std::same_as<K>;};
286
287template<class K, typename T>
288concept defines_add_for = requires(K klass, T type) {{ klass + type};};
289
290template<class K>
291concept defines_add_s = defines_add_for_s<K, K>;
292
293template<class K>
294concept defines_add = defines_add_for<K, K>;
295
296template<class K, typename T>
297concept defines_sub_for_s = requires(K klass, T type) {{ klass - type } -> std::same_as<K>;};
298
299template<class K, typename T>
300concept defines_sub_for = requires(K klass, T type) {{ klass - type };};
301
302template<class K>
303concept defines_sub_s = defines_sub_for_s<K, K>;
304
305template<class K>
306concept defines_sub = defines_sub_for<K, K>;
307
308template<class K, typename T>
309concept defines_mult_for_s = requires(K klass, T type) {{ klass * type } -> std::same_as<K>;};
310
311template<class K, typename T>
312concept defines_mult_for = requires(K klass, T type) {{ klass * type };};
313
314template<class K>
315concept defines_mult_s = defines_mult_for_s<K, K>;
316
317template<class K>
318concept defines_mult = defines_mult_for<K, K>;
319
320template<class K, typename T>
321concept defines_div_for_s = requires(K klass, T type) {{ klass / type } -> std::same_as<K>;};
322
323template<class K, typename T>
324concept defines_div_for = requires(K klass, T type) {{ klass / type };};
325
326template<class K>
327concept defines_div_s = defines_div_for_s<K, K>;
328
329template<class K>
330concept defines_div = defines_div_for<K, K>;
331
332template<class K, typename T>
333concept defines_mod_for_s = requires(K klass, T type) {{ klass % type } -> std::same_as<K>;};
334
335template<class K, typename T>
336concept defines_mod_for = requires(K klass, T type) {{ klass % type };};
337
338template<class K>
339concept defines_mod_s = defines_mod_for_s<K, K>;
340
341template<class K>
342concept defines_mod = defines_mod_for<K, K>;
343
344template<class K>
345concept defines_bit_not_s = requires(K klass) {{ ~klass } -> std::same_as<K>;};
346
347template<class K>
348concept defines_bit_not = requires(K klass) {{ ~klass };};
349
350template<class K, typename T>
351concept defines_bit_and_for_s = requires(K klass, T type) {{ klass & type } -> std::same_as<K>;};
352
353template<class K, typename T>
354concept defines_bit_and_for = requires(K klass, T type) {{ klass & type };};
355
356template<class K>
357concept defines_bit_and_s = defines_bit_and_for_s<K, K>;
358
359template<class K>
360concept defines_bit_and = defines_bit_and_for<K, K>;
361
362template<class K, typename T>
363concept defines_bit_or_for_s = requires(K klass, T type) {{ klass | type } -> std::same_as<K>;};
364
365template<class K, typename T>
366concept defines_bit_or_for = requires(K klass, T type) {{ klass | type };};
367
368template<class K>
369concept defines_bit_or_s = defines_bit_or_for_s<K, K>;
370
371template<class K>
372concept defines_bit_or = defines_bit_or_for<K, K>;
373
374template<class K, typename T>
375concept defines_bit_xor_for_s = requires(K klass, T type) {{ klass ^ type } -> std::same_as<K>;};
376
377template<class K, typename T>
378concept defines_bit_xor_for = requires(K klass, T type) {{ klass ^ type };};
379
380template<class K>
381concept defines_bit_xor_s = defines_bit_xor_for_s<K, K>;
382
383template<class K>
384concept defines_bit_xor = defines_bit_xor_for<K, K>;
385
386template<class K, typename T>
387concept defines_left_shift_for_s = requires(K klass, T type) {{ klass << type } -> std::same_as<K>;};
388
389template<class K, typename T>
390concept defines_left_shift_for = requires(K klass, T type) {{ klass << type };};
391
392template<class K>
393concept defines_left_shift_s = defines_left_shift_for_s<K, K>;
394
395template<class K>
396concept defines_left_shift = defines_left_shift_for<K, K>;
397
398template<class K, typename T>
399concept defines_right_shift_for_s = requires(K klass, T type) {{ klass >> type } -> std::same_as<K>;};
400
401template<class K, typename T>
402concept defines_right_shift_for = requires(K klass, T type) {{ klass >> type };};
403
404template<class K>
405concept defines_right_shift_s = defines_right_shift_for_s<K, K>;
406
407template<class K>
408concept defines_right_shift = defines_right_shift_for<K, K>;
409
410// Comparison operators
411template<class K, typename T>
412concept defines_equality_for_s = requires(K klass, T type) {{ klass == type } -> std::same_as<bool>;};
413
414template<class K, typename T>
415concept defines_equality_for = requires(K klass, T type) {{ klass == type };};
416
417template<class K>
418concept defines_equality_s = defines_equality_for_s<K, K>;
419
420template<class K>
421concept defines_equality = defines_equality_for<K, K>;
422
423template<class K, typename T>
424concept defines_inequality_for_s = requires(K klass, T type) {{ klass != type } -> std::same_as<bool>;};
425
426template<class K, typename T>
427concept defines_inequality_for = requires(K klass, T type) {{ klass != type };};
428
429template<class K>
430concept defines_inequality_s = defines_inequality_for_s<K, K>;
431
432template<class K>
433concept defines_inequality = defines_inequality_for<K, K>;
434
435template<class K, typename T>
436concept defines_less_than_for_s = requires(K klass, T type) {{ klass < type } -> std::same_as<bool>;};
437
438template<class K, typename T>
439concept defines_less_than_for = requires(K klass, T type) {{ klass < type };};
440
441template<class K>
442concept defines_less_than_s = defines_less_than_for_s<K, K>;
443
444template<class K>
445concept defines_less_than = defines_less_than_for<K, K>;
446
447template<class K, typename T>
448concept defines_greater_than_for_s = requires(K klass, T type) {{ klass > type } -> std::same_as<bool>;};
449
450template<class K, typename T>
451concept defines_greater_than_for = requires(K klass, T type) {{ klass > type };};
452
453template<class K>
454concept defines_greater_than_s = defines_greater_than_for_s<K, K>;
455
456template<class K>
457concept defines_greater_than = defines_greater_than_for<K, K>;
458
459template<class K, typename T>
460concept defines_less_than_equal_for_s = requires(K klass, T type) {{ klass <= type } -> std::same_as<bool>;};
461
462template<class K, typename T>
463concept defines_less_than_equal_for = requires(K klass, T type) {{ klass <= type };};
464
465template<class K>
466concept defines_less_than_equal_s = defines_less_than_equal_for_s<K, K>;
467
468template<class K>
469concept defines_less_than_equal = defines_less_than_equal_for<K, K>;
470
471template<class K, typename T>
472concept defines_greater_than_equal_for_s = requires(K klass, T type) {{ klass >= type } -> std::same_as<bool>;};
473
474template<class K, typename T>
475concept defines_greater_than_equal_for = requires(K klass, T type) {{ klass >= type };};
476
477template<class K>
478concept defines_greater_than_equal_s = defines_greater_than_equal_for_s<K, K>;
479
480template<class K>
481concept defines_greater_than_equal = defines_greater_than_equal_for<K, K>;
482
483template<class K, typename T>
484concept defines_three_way_comp_for_s = requires(K klass, T type) {{ klass <=> type } -> std::convertible_to<std::partial_ordering>;};
485
486template<class K, typename T>
487concept defines_three_way_comp_for = requires(K klass, T type) {{ klass <=> type };};
488
489template<class K>
490concept defines_three_way_comp_s = defines_three_way_comp_for_s<K, K>;
491
492template<class K>
493concept defines_three_way_comp = defines_three_way_comp_for<K, K>;
494
495// Trait
496template<class K>
497concept arithmetic = std::is_arithmetic_v<K>;
498
499template<class K>
500concept fundamental = std::is_fundamental_v<K>;
501
502template<class K>
503concept traverseable = std::bidirectional_iterator<typename K::const_iterator> &&
504 std::is_default_constructible_v<K> &&
505 requires(K klass) {{ klass.size() } -> std::integral<>;};
506
507// Conversion
508template<class K, typename T>
509concept static_castable_to = requires(K klass) {{ static_cast<T>(klass) };};
510
511// Grouping
512template<class K, class ... L>
513concept any_of = (std::same_as<K, L> || ...);
514
515// Template
516template<typename K, template <typename...> class L>
517concept specializes = QxConceptsPrivate::is_specialization_of_v<K, L>;
518
519// Similiar interface types
520template<typename T>
521concept qassociative = specializes<T, QHash> ||
522 specializes<T, QMap>;
523
524template<typename T>
525concept qcollective = specializes<T, QList> ||
526 specializes<T, QSet>;
527
528}
529
530#endif // QX_CONCEPTS_H
Qx::any_of
Specifies that a type is one of several types.
Definition qx-concepts.h:513
Qx::arithmetic
Specifies that a type is an arithmetic type.
Definition qx-concepts.h:497
Qx::defines_add_assign_for_s
Specifies that a type defines an addition assignment operator for another type (with strict return).
Definition qx-concepts.h:46
Qx::defines_add_assign_for
Specifies that a type defines an addition assignment operator for another type.
Definition qx-concepts.h:49
Qx::defines_add_assign_s
Specifies that a type defines an addition assignment operator for itself (with strict return).
Definition qx-concepts.h:52
Qx::defines_add_assign
Specifies that a type defines an addition assignment operator for itself.
Definition qx-concepts.h:55
Qx::defines_add_for_s
Specifies that a type defines an addition operator for another type (with strict return).
Definition qx-concepts.h:285
Qx::defines_add_for
Specifies that a type defines an addition operator for another type.
Definition qx-concepts.h:288
Qx::defines_add_s
Specifies that a type defines an addition operator for itself (with strict return).
Definition qx-concepts.h:291
Qx::defines_add
Specifies that a type defines an addition operator for itself.
Definition qx-concepts.h:294
Qx::defines_address_of_s
Specifies that a type defines an address-of operator (with strict return).
Definition qx-concepts.h:235
Qx::defines_address_of
Specifies that a type defines an address-of operator.
Definition qx-concepts.h:238
Qx::defines_and_for_s
Specifies that a type defines a logical AND operator for another type (with strict return).
Definition qx-concepts.h:198
Qx::defines_and_for
Specifies that a type defines a logical AND operator for another type.
Definition qx-concepts.h:201
Qx::defines_and_s
Specifies that a type defines a logical AND operator for itself (with strict return)....
Definition qx-concepts.h:204
Qx::defines_and
Specifies that a type defines a logical AND operator for itself.
Definition qx-concepts.h:207
Qx::defines_assign_for_s
Specifies that a type defines a simple assignment operator for another type (with strict return).
Definition qx-concepts.h:34
Qx::defines_assign_for
Specifies that a type defines a simple assignment operator for another type.
Definition qx-concepts.h:37
Qx::defines_assign_s
Specifies that a type defines a simple assignment operator for itself (with strict return).
Definition qx-concepts.h:40
Qx::defines_assign
Specifies that a type defines a simple assignment operator for itself.
Definition qx-concepts.h:43
Qx::defines_bit_and_assign_for_s
Specifies that a type defines a bitwise AND assignment operator for another type (with strict return)...
Definition qx-concepts.h:106
Qx::defines_bit_and_assign_for
Specifies that a type defines a bitwise AND assignment operator for another type.
Definition qx-concepts.h:109
Qx::defines_bit_and_assign_s
Specifies that a type defines a bitwise AND assignment operator for itself (with strict return).
Definition qx-concepts.h:112
Qx::defines_bit_and_assign
Specifies that a type defines a bitwise AND assignment operator for itself.
Definition qx-concepts.h:115
Qx::defines_bit_and_for_s
Specifies that a type defines a bitwise AND operator for another type (with strict return).
Definition qx-concepts.h:351
Qx::defines_bit_and_for
Specifies that a type defines a bitwise AND operator for another type.
Definition qx-concepts.h:354
Qx::defines_bit_and_s
Specifies that a type defines a bitwise AND operator for itself (with strict return).
Definition qx-concepts.h:357
Qx::defines_bit_and
Specifies that a type defines a bitwise AND operator for itself.
Definition qx-concepts.h:360
Qx::defines_bit_not_s
Specifies that a type defines a bitwise NOT operator (with strict return).
Definition qx-concepts.h:345
Qx::defines_bit_not
Specifies that a type defines a bitwise NOT operator.
Definition qx-concepts.h:348
Qx::defines_bit_or_assign_for_s
Specifies that a type defines a bitwise OR assignment operator for another type (with strict return).
Definition qx-concepts.h:118
Qx::defines_bit_or_assign_for
Specifies that a type defines a bitwise OR assignment operator for another type.
Definition qx-concepts.h:121
Qx::defines_bit_or_assign_s
Specifies that a type defines a bitwise OR assignment operator for itself (with strict return).
Definition qx-concepts.h:124
Qx::defines_bit_or_assign
Specifies that a type defines a bitwise OR assignment operator for itself.
Definition qx-concepts.h:127
Qx::defines_bit_or_for_s
Specifies that a type defines a bitwise OR operator for another type (with strict return).
Definition qx-concepts.h:363
Qx::defines_bit_or_for
Specifies that a type defines a bitwise OR operator for another type.
Definition qx-concepts.h:366
Qx::defines_bit_or_s
Specifies that a type defines a bitwise OR operator for itself (with strict return).
Definition qx-concepts.h:369
Qx::defines_bit_or
Specifies that a type defines a bitwise OR operator for itself.
Definition qx-concepts.h:372
Qx::defines_bit_xor_assign_for_s
Specifies that a type defines a bitwise XOR assignment operator for another type (with strict return)...
Definition qx-concepts.h:130
Qx::defines_bit_xor_assign_for
Specifies that a type defines a bitwise XOR assignment operator for another type.
Definition qx-concepts.h:133
Qx::defines_bit_xor_assign_s
Specifies that a type defines a bitwise XOR assignment operator for itself (with strict return).
Definition qx-concepts.h:136
Qx::defines_bit_xor_assign
Specifies that a type defines a bitwise XOR assignment operator for itself.
Definition qx-concepts.h:139
Qx::defines_bit_xor_for_s
Specifies that a type defines a bitwise XOR operator for another type (with strict return).
Definition qx-concepts.h:375
Qx::defines_bit_xor_for
Specifies that a type defines a bitwise XOR operator for another type.
Definition qx-concepts.h:378
Qx::defines_bit_xor_s
Specifies that a type defines a bitwise XOR operator for itself (with strict return).
Definition qx-concepts.h:381
Qx::defines_bit_xor
Specifies that a type defines a bitwise XOR operator for itself.
Definition qx-concepts.h:384
Qx::defines_call_for_s
Specifies that a type defines a call operator for the specified argument types (with strict return).
Definition qx-concepts.h:253
Qx::defines_call_for
Specifies that a type defines a call operator for the specified argument types.
Definition qx-concepts.h:256
Qx::defines_call_s
Specifies that a type defines a argumentless call operator (with strict return).
Definition qx-concepts.h:259
Qx::defines_call
Specifies that a type defines a argumentless call operator.
Definition qx-concepts.h:262
Qx::defines_comma_for_s
Specifies that a type defines a comma operator for another type (with strict return).
Definition qx-concepts.h:265
Qx::defines_comma_for
Specifies that a type defines a comma operator for another type.
Definition qx-concepts.h:268
Qx::defines_div_assign_for_s
Specifies that a type defines a division assignment operator for another type (with strict return).
Definition qx-concepts.h:82
Qx::defines_div_assign_for
Specifies that a type defines a division assignment operator for another type.
Definition qx-concepts.h:85
Qx::defines_div_assign_s
Specifies that a type defines a division assignment operator for itself (with strict return).
Definition qx-concepts.h:88
Qx::defines_div_assign
Specifies that a type defines a division assignment operator for itself.
Definition qx-concepts.h:91
Qx::defines_div_for_s
Specifies that a type defines a division operator for another type (with strict return).
Definition qx-concepts.h:321
Qx::defines_div_for
Specifies that a type defines a division operator for another type.
Definition qx-concepts.h:324
Qx::defines_div_s
Specifies that a type defines a division operator for itself (with strict return).
Definition qx-concepts.h:327
Qx::defines_div
Specifies that a type defines a division operator for itself.
Definition qx-concepts.h:330
Qx::defines_equality_for_s
Specifies that a type defines an equal to operator for another type (with strict return).
Definition qx-concepts.h:412
Qx::defines_equality_for
Specifies that a type defines an equal to operator for another type.
Definition qx-concepts.h:415
Qx::defines_equality_s
Specifies that a type defines an equal to operator for itself (with strict return).
Definition qx-concepts.h:418
Qx::defines_equality
Specifies that a type defines an equal to operator for itself (with strict return).
Definition qx-concepts.h:421
Qx::defines_greater_than_equal_for_s
Specifies that a type defines a greater than or equal to operator for another type (with strict retur...
Definition qx-concepts.h:472
Qx::defines_greater_than_equal_for
Specifies that a type defines a greater than or equal to operator for another type.
Definition qx-concepts.h:475
Qx::defines_greater_than_equal_s
Specifies that a type defines a greater than or equal to operator for itself (with strict return).
Definition qx-concepts.h:478
Qx::defines_greater_than_equal
Specifies that a type defines a greater than or equal to operator for itself.
Definition qx-concepts.h:481
Qx::defines_greater_than_for_s
Specifies that a type defines a greater than operator for another type (with strict return).
Definition qx-concepts.h:448
Qx::defines_greater_than_for
Specifies that a type defines a greater than operator for another type.
Definition qx-concepts.h:451
Qx::defines_greater_than_s
Specifies that a type defines a greater than operator for itself (with strict return).
Definition qx-concepts.h:454
Qx::defines_greater_than
Specifies that a type defines a greater than operator for itself.
Definition qx-concepts.h:457
Qx::defines_indirection_s
Specifies that a type defines an indirection operator (with strict return).
Definition qx-concepts.h:229
Qx::defines_indirection
Specifies that a type defines an indirection operator.
Definition qx-concepts.h:232
Qx::defines_inequality_for_s
Specifies that a type defines a not equal to operator for another type (with strict return).
Definition qx-concepts.h:424
Qx::defines_inequality_for
Specifies that a type defines a not equal to operator for another type.
Definition qx-concepts.h:427
Qx::defines_inequality_s
Specifies that a type defines a not equal to operator for itself (with strict return).
Definition qx-concepts.h:430
Qx::defines_inequality
Specifies that a type defines a not equal to operator for itself (with strict return).
Definition qx-concepts.h:433
Qx::defines_left_shift_assign_for_s
Specifies that a type defines a left shift assignment operator for another type (with strict return).
Definition qx-concepts.h:142
Qx::defines_left_shift_assign_for
Specifies that a type defines a left shift assignment operator for another type.
Definition qx-concepts.h:145
Qx::defines_left_shift_assign_s
Specifies that a type defines a left shift assignment operator for itself (with strict return).
Definition qx-concepts.h:148
Qx::defines_left_shift_assign
Specifies that a type defines a left shift assignment operator for itself.
Definition qx-concepts.h:151
Qx::defines_left_shift_for_s
Specifies that a type defines a left shift operator for another type (with strict return).
Definition qx-concepts.h:387
Qx::defines_left_shift_for
Specifies that a type defines a left shift operator for another type.
Definition qx-concepts.h:390
Qx::defines_left_shift_s
Specifies that a type defines a left shift operator for itself (with strict return).
Definition qx-concepts.h:393
Qx::defines_left_shift
Specifies that a type defines a left shift operator for itself.
Definition qx-concepts.h:396
Qx::defines_less_than_equal_for_s
Specifies that a type defines a less than or equal to operator for another type (with strict return).
Definition qx-concepts.h:460
Qx::defines_less_than_equal_for
Specifies that a type defines a less than or equal to operator for another type.
Definition qx-concepts.h:463
Qx::defines_less_than_equal_s
Specifies that a type defines a less than or equal to operator for itself (with strict return).
Definition qx-concepts.h:466
Qx::defines_less_than_equal
Specifies that a type defines a less than or equal to operator for itself.
Definition qx-concepts.h:469
Qx::defines_less_than_for_s
Specifies that a type defines a less than operator for another type (with strict return).
Definition qx-concepts.h:436
Qx::defines_less_than_for
Specifies that a type defines a less than operator for another type.
Definition qx-concepts.h:439
Qx::defines_less_than_s
Specifies that a type defines a less than operator for itself (with strict return).
Definition qx-concepts.h:442
Qx::defines_less_than
Specifies that a type defines a less than operator for itself.
Definition qx-concepts.h:445
Qx::defines_mod_assign_for_s
Specifies that a type defines a modulo assignment operator for another type (with strict return).
Definition qx-concepts.h:94
Qx::defines_mod_assign_for
Specifies that a type defines a modulo assignment operator for another type.
Definition qx-concepts.h:97
Qx::defines_mod_assign_s
Specifies that a type defines a modulo assignment operator for itself (with strict return).
Definition qx-concepts.h:100
Qx::defines_mod_assign
Specifies that a type defines a modulo assignment operator for itself.
Definition qx-concepts.h:103
Qx::defines_mod_for_s
Specifies that a type defines a modulo operator for another type (with strict return).
Definition qx-concepts.h:333
Qx::defines_mod_for
Specifies that a type defines a modulo operator for another type.
Definition qx-concepts.h:336
Qx::defines_mod_s
Specifies that a type defines a modulo operator for itself (with strict return).
Definition qx-concepts.h:339
Qx::defines_mod
Specifies that a type defines a modulo operator for itself.
Definition qx-concepts.h:342
Qx::defines_mult_assign_for_s
Specifies that a type defines a multiplication assignment operator for another type (with strict retu...
Definition qx-concepts.h:70
Qx::defines_mult_assign_for
Specifies that a type defines a multiplication assignment operator for another type.
Definition qx-concepts.h:73
Qx::defines_mult_assign_s
Specifies that a type defines a multiplication assignment operator for itself (with strict return).
Definition qx-concepts.h:76
Qx::defines_mult_assign
Specifies that a type defines a multiplication assignment operator for itself.
Definition qx-concepts.h:79
Qx::defines_mult_for_s
Specifies that a type defines a multiplication operator for another type (with strict return).
Definition qx-concepts.h:309
Qx::defines_mult_for
Specifies that a type defines a multiplication operator for another type.
Definition qx-concepts.h:312
Qx::defines_mult_s
Specifies that a type defines a multiplication operator for itself (with strict return).
Definition qx-concepts.h:315
Qx::defines_mult
Specifies that a type defines a multiplication operator for itself.
Definition qx-concepts.h:318
Qx::defines_negation_s
Specifies that a type defines a negation operator (with strict return).
Definition qx-concepts.h:192
Qx::defines_negation
Specifies that a type defines a negation operator.
Definition qx-concepts.h:195
Qx::defines_or_for_s
Specifies that a type defines a logical OR operator for another type (with strict return).
Definition qx-concepts.h:210
Qx::defines_or_for
Specifies that a type defines a logical OR operator for another type.
Definition qx-concepts.h:213
Qx::defines_or_s
Specifies that a type defines a logical OR operator for itself (with strict return).
Definition qx-concepts.h:216
Qx::defines_or
Specifies that a type defines a logical OR operator for itself.
Definition qx-concepts.h:219
Qx::defines_post_decrement_s
Specifies that a type defines a post-decrement operator (with strict return).
Definition qx-concepts.h:185
Qx::defines_post_decrement
Specifies that a type defines a post-decrement operator.
Definition qx-concepts.h:188
Qx::defines_post_increment_s
Specifies that a type defines a post-increment operator (with strict return).
Definition qx-concepts.h:179
Qx::defines_post_increment
Specifies that a type defines a post-increment operator.
Definition qx-concepts.h:182
Qx::defines_pre_decrement_s
Specifies that a type defines a pre-decrement operator (with strict return).
Definition qx-concepts.h:173
Qx::defines_pre_decrement
Specifies that a type defines a pre-decrement operator.
Definition qx-concepts.h:176
Qx::defines_pre_increment_s
Specifies that a type defines a pre-increment operator (with strict return).
Definition qx-concepts.h:167
Qx::defines_pre_increment
Specifies that a type defines a pre-increment operator.
Definition qx-concepts.h:170
Qx::defines_ptr_to_member_ptr_for_s
Specifies that a type defines a pointer to member of pointer operator (with strict return).
Definition qx-concepts.h:246
Qx::defines_ptr_to_member_ptr_for
Specifies that a type defines a pointer to member of pointer operator.
Definition qx-concepts.h:249
Qx::defines_right_shift_assign_for_s
Specifies that a type defines a right shift assignment operator for another type (with strict return)...
Definition qx-concepts.h:154
Qx::defines_right_shift_assign_for
Specifies that a type defines a right shift assignment operator for another type.
Definition qx-concepts.h:157
Qx::defines_right_shift_assign_s
Specifies that a type defines a right shift assignment operator for itself (with strict return).
Definition qx-concepts.h:160
Qx::defines_right_shift_assign
Specifies that a type defines a right shift assignment operator for itself.
Definition qx-concepts.h:163
Qx::defines_right_shift_for_s
Specifies that a type defines a right shift operator for another type (with strict return).
Definition qx-concepts.h:399
Qx::defines_right_shift_for
Specifies that a type defines a right shift operator for another type.
Definition qx-concepts.h:402
Qx::defines_right_shift_s
Specifies that a type defines a right shift operator for itself (with strict return).
Definition qx-concepts.h:405
Qx::defines_right_shift
Specifies that a type defines a right shift operator for itself.
Definition qx-concepts.h:408
Qx::defines_sub_assign_for_s
Specifies that a type defines a subtraction assignment operator for another type (with strict return)...
Definition qx-concepts.h:58
Qx::defines_sub_assign_for
Specifies that a type defines a subtraction assignment operator for another type.
Definition qx-concepts.h:61
Qx::defines_sub_assign_s
Specifies that a type defines a subtraction assignment operator for itself (with strict return).
Definition qx-concepts.h:64
Qx::defines_sub_assign
Specifies that a type defines a subtraction assignment operator for itself.
Definition qx-concepts.h:67
Qx::defines_sub_for_s
Specifies that a type defines a subtraction operator for another type (with strict return).
Definition qx-concepts.h:297
Qx::defines_sub_for
Specifies that a type defines a subtraction operator for another type.
Definition qx-concepts.h:300
Qx::defines_sub_s
Specifies that a type defines a subtraction operator for itself (with strict return).
Definition qx-concepts.h:303
Qx::defines_sub
Specifies that a type defines a subtraction operator for itself.
Definition qx-concepts.h:306
Qx::defines_subscript_for_s
Specifies that a type defines a subscript operator for another type (with strict return).
Definition qx-concepts.h:223
Qx::defines_subscript_for
Specifies that a type defines a subscript operator for another type.
Definition qx-concepts.h:226
Qx::defines_three_way_comp_for_s
Specifies that a type defines a three-way comparison operator for another type (with strict return).
Definition qx-concepts.h:484
Qx::defines_three_way_comp_for
Specifies that a type defines a three-way comparison operator for another type.
Definition qx-concepts.h:487
Qx::defines_three_way_comp_s
Specifies that a type defines a three-way comparison operator for itself (with strict return).
Definition qx-concepts.h:490
Qx::defines_three_way_comp
Specifies that a type defines a three-way comparison operator for itself.
Definition qx-concepts.h:493
Qx::defines_unary_minus_s
Specifies that a type defines a unary minus operator (with strict return).
Definition qx-concepts.h:279
Qx::defines_unary_minus
Specifies that a type defines a unary minus operator.
Definition qx-concepts.h:282
Qx::defines_unary_plus_s
Specifies that a type defines a unary plus operator (with strict return).
Definition qx-concepts.h:273
Qx::defines_unary_plus
Specifies that a type defines a unary plus operator.
Definition qx-concepts.h:276
Qx::fundamental
Specifies that a type is a fundamental type.
Definition qx-concepts.h:500
Qx::qassociative
Specifies that a type is a Qt-based associative container type.
Definition qx-concepts.h:521
Qx::qcollective
Specifies that a type is a Qt-based collection type.
Definition qx-concepts.h:525
Qx::specializes
Specifies that a type is a specialization of a template.
Definition qx-concepts.h:517
Qx::static_castable_to
Specifies that a type can be statically cast to another type.
Definition qx-concepts.h:509
Qx::traverseable
Specifies that a type is a valid type for Qx::Traverser.
Definition qx-concepts.h:503
Qx
The Qx namespace is the main namespace through which all non-global functionality of the Qx library i...
Definition qx-processwaiter.cpp:5