Skip to content

Commit 4b7bb05

Browse files
evoskuilevoskuil
committed
Add if_common_type<> (and is_common_type, is_base_type), tests.
1 parent c4461c3 commit 4b7bb05

4 files changed

Lines changed: 100 additions & 63 deletions

File tree

‎include/bitcoin/system/constraints.hpp‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -118,6 +118,10 @@ template <typename Base, typename Type>
118118
using if_not_base_of = bool_if<
119119
!std::is_base_of<Base, Type>::value>;
120120

121+
template <typename Left, typename Right>
122+
using if_common_type = bool_if<
123+
is_common_type<Left, Right>>;
124+
121125
template <typename Left, typename Right>
122126
using if_same_size = bool_if<
123127
is_same_size<Left, Right>>;

‎include/bitcoin/system/typelets.hpp‎

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,16 @@ template <typename Left, typename Right>
3232
constexpr bool is_same_type = std::is_same_v<std::decay_t<Left>,
3333
std::decay_t<Right>>;
3434

35+
/// Left is base class of Right, independent of const and volatility.
36+
template <typename Left, typename Right>
37+
constexpr bool is_base_type = std::is_base_of_v<std::decay_t<Left>,
38+
std::decay_t<Right>>;
39+
40+
/// Types share a common base class or are the same type.
41+
template <typename Left, typename Right>
42+
constexpr bool is_common_type = is_base_type<Left, Right> ||
43+
is_base_type<Right, Left>;
44+
3545
/// Alias - bool is unsigned: bool(-1) < bool(0). w/char sign unspecified.
3646
/// w/charxx_t types are unsigned. iostream relies on w/char.
3747
template <typename Type>
@@ -76,8 +86,7 @@ constexpr bool is_integral_integer = is_integral<Type> /*&& is_integer<Type>*/;
7686

7787
/// numeric_limits may be specialized by non-integrals (such as uintx).
7888
template <typename Type>
79-
constexpr bool is_floating_point =
80-
std::is_floating_point_v<std::decay_t<Type>>;
89+
constexpr bool is_floating_point = std::is_floating_point_v<std::decay_t<Type>>;
8190

8291
/// Constrained to is_integral types.
8392
template <typename Type, std::enable_if_t<is_integral_size<Type>, bool> = true>

‎test/constraints.cpp‎

Lines changed: 63 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -18,18 +18,21 @@
1818
*/
1919
#include "test.hpp"
2020

21-
2221
// helpers
2322

2423
typedef bool non_constant;
2524
typedef const bool constant;
26-
class base {};
25+
class not_default_constructible { not_default_constructible(int) {} };
26+
2727
class not_derived {};
28+
class base {};
2829
class derived : base {};
29-
////class not_default_constructible { not_default_constructible(int) {}};
30+
class more_derived : derived {};
31+
class also_derived : base {};
32+
class more_also_derived : also_derived {};
3033

31-
template <typename>
32-
constexpr bool is_defined = true;
34+
template <typename Type>
35+
constexpr bool is_defined = !std::is_void_v<Type>;
3336

3437
// sizes
3538

@@ -129,16 +132,16 @@ static_assert(is_defined<if_not_same<char, bool>>);
129132

130133
static_assert(is_defined<if_one_byte<int8_t>>);
131134
static_assert(is_defined<if_one_byte<uint8_t>>);
132-
////static_assert(is_defined<if_one_byte<char>>);
133-
////static_assert(is_defined<if_one_byte<bool>>);
135+
static_assert(is_defined<if_one_byte<char>>);
136+
static_assert(is_defined<if_one_byte<bool>>);
134137
////static_assert(!is_defined<if_one_byte<uint256_t>>);
135138
////static_assert(!is_defined<if_one_byte<float>>);
136139
////static_assert(!is_defined<if_one_byte<double>>);
137140
////static_assert(!is_defined<if_one_byte<int16_t>>);
138141
////static_assert(!is_defined<if_one_byte<uint32_t>>);
139142
////static_assert(!is_defined<if_one_byte<int64_t>>);
140143
////static_assert(!is_defined<if_one_byte<size_t>>);
141-
////static_assert(!is_defined<if_one_byte<base>>);
144+
////////static_assert(!is_defined<if_one_byte<base>>);
142145

143146
static_assert(is_defined<if_not_one_byte<int16_t>>);
144147
static_assert(is_defined<if_not_one_byte<uint32_t>>);
@@ -164,10 +167,10 @@ static_assert(is_defined<if_size_of<signed_size_t, sizeof(size_t)>>);
164167
////static_assert(!is_defined<if_size_of<int, sizeof(bool)>>);
165168

166169
static_assert(is_defined<if_const<constant>>);
167-
////static_assert(!is_defined<if_const<is_non_constant>>);
170+
////static_assert(!is_defined<if_const<non_constant>>);
168171

169172
static_assert(is_defined<if_non_const<non_constant>>);
170-
////static_assert(!is_defined<if_non_const<is_constant>>);
173+
////static_assert(!is_defined<if_non_const<constant>>);
171174

172175
static_assert(is_defined<if_base_of<base, base>>);
173176
static_assert(is_defined<if_base_of<base, derived>>);
@@ -183,6 +186,19 @@ static_assert(is_defined<if_not_base_of<float, double>>);
183186
////static_assert(!is_defined<if_not_base_of<base, base>>);
184187
////static_assert(!is_defined<if_not_base_of<base, derived>>);
185188

189+
static_assert(is_defined<if_common_type<base, base>>);
190+
static_assert(is_defined<if_common_type<base, derived>>);
191+
static_assert(is_defined<if_common_type<derived, derived>>);
192+
static_assert(is_defined<if_common_type<derived, base>>);
193+
static_assert(is_defined<if_common_type<derived, more_derived>>);
194+
static_assert(is_defined<if_common_type<more_derived, derived>>);
195+
static_assert(is_defined<if_common_type<also_derived, more_also_derived>>);
196+
static_assert(is_defined<if_common_type<more_also_derived, also_derived>>);
197+
////static_assert(!is_defined<if_common_type<derived, also_derived>>);
198+
////static_assert(!is_defined<if_common_type<also_derived, derived>>);
199+
////static_assert(!is_defined<if_common_type<base, not_derived>>);
200+
////static_assert(!is_defined<if_common_type<not_derived, base>>);
201+
186202
static_assert(is_defined<if_same_size<bool, bool>>);
187203
static_assert(is_defined<if_same_size<int, int>>);
188204
static_assert(is_defined<if_same_size<int8_t, int8_t>>);
@@ -202,10 +218,6 @@ static_assert(is_defined<if_same_size<uint64_t, int64_t>>);
202218
////static_assert(!is_defined<if_same_size<int16_t, int32_t>>);
203219
////static_assert(!is_defined<if_same_size<int16_t, int64_t>>);
204220
////static_assert(!is_defined<if_same_size<int32_t, int64_t>>);
205-
////static_assert(is_defined<if_same_size<int, uint32_t>>);
206-
////static_assert(is_defined<if_same_size<int32_t, int>>);
207-
////static_assert(!is_defined<if_same_size<bool, int>>);
208-
////static_assert(!is_defined<if_same_size<int, bool>>);
209221

210222
static_assert(is_defined<if_not_same_size<int8_t, int16_t>>);
211223
static_assert(is_defined<if_not_same_size<int8_t, int32_t>>);
@@ -216,28 +228,23 @@ static_assert(is_defined<if_not_same_size<int8_t, int64_t>>);
216228
static_assert(is_defined<if_not_same_size<int16_t, int32_t>>);
217229
static_assert(is_defined<if_not_same_size<int16_t, int64_t>>);
218230
static_assert(is_defined<if_not_same_size<int32_t, int64_t>>);
219-
////static_assert(is_defined<if_not_same_size<bool, bool>>);
220-
////static_assert(is_defined<if_not_same_size<int, int>>);
221-
////static_assert(is_defined<if_not_same_size<int8_t, int8_t>>);
222-
////static_assert(is_defined<if_not_same_size<uint8_t, uint8_t>>);
223-
////static_assert(is_defined<if_not_same_size<int16_t, uint16_t>>);
224-
////static_assert(is_defined<if_not_same_size<uint16_t, int16_t>>);
225-
////static_assert(is_defined<if_not_same_size<int32_t, uint32_t>>);
226-
////static_assert(is_defined<if_not_same_size<uint32_t, int32_t>>);
227-
////static_assert(is_defined<if_not_same_size<int64_t, uint64_t>>);
228-
////static_assert(is_defined<if_not_same_size<uint64_t, int64_t>>);
229-
////static_assert(is_defined<if_not_same_size<int, uint32_t>>);
230-
////static_assert(is_defined<if_not_same_size<int32_t, int>>);
231-
////static_assert(is_defined<if_not_same_size<bool, int>>);
232-
////static_assert(is_defined<if_not_same_size<int, bool>>);
231+
232+
////static_assert(!is_defined<if_not_same_size<int8_t, int8_t>>);
233+
////static_assert(!is_defined<if_not_same_size<uint8_t, uint8_t>>);
234+
////static_assert(!is_defined<if_not_same_size<int16_t, uint16_t>>);
235+
////static_assert(!is_defined<if_not_same_size<uint16_t, int16_t>>);
236+
////static_assert(!is_defined<if_not_same_size<int32_t, uint32_t>>);
237+
////static_assert(!is_defined<if_not_same_size<uint32_t, int32_t>>);
238+
////static_assert(!is_defined<if_not_same_size<int64_t, uint64_t>>);
239+
////static_assert(!is_defined<if_not_same_size<uint64_t, int64_t>>);
233240

234241
static_assert(is_defined<if_lesser_size<int8_t, int16_t>>);
235242
static_assert(is_defined<if_lesser_size<int8_t, int32_t>>);
236243
static_assert(is_defined<if_lesser_size<int8_t, int64_t>>);
237244
static_assert(is_defined<if_lesser_size<int16_t, int32_t>>);
238245
static_assert(is_defined<if_lesser_size<int16_t, int64_t>>);
239246
static_assert(is_defined<if_lesser_size<int32_t, int64_t>>);
240-
////static_assert(is_defined<if_lesser_size<bool, int>>);
247+
static_assert(is_defined<if_lesser_size<bool, int>>);
241248
////static_assert(!is_defined<if_lesser_size<bool, bool>>);
242249
////static_assert(!is_defined<if_lesser_size<int, int>>);
243250
////static_assert(!is_defined<if_lesser_size<int, uint32_t>>);
@@ -271,7 +278,7 @@ static_assert(is_defined<if_not_lesser_size<int32_t, uint32_t>>);
271278
static_assert(is_defined<if_not_lesser_size<uint32_t, int32_t>>);
272279
static_assert(is_defined<if_not_lesser_size<int64_t, uint64_t>>);
273280
static_assert(is_defined<if_not_lesser_size<uint64_t, int64_t>>);
274-
////static_assert(is_defined<if_not_lesser_size<int, bool>>);
281+
static_assert(is_defined<if_not_lesser_size<int, bool>>);
275282
////static_assert(!is_defined<if_not_lesser_size<bool, int>>);
276283
////static_assert(!is_defined<if_not_lesser_size<int8_t, int16_t>>);
277284
////static_assert(!is_defined<if_not_lesser_size<int8_t, int32_t>>);
@@ -286,20 +293,16 @@ static_assert(is_defined<if_greater_size<int64_t, int8_t>>);
286293
static_assert(is_defined<if_greater_size<int32_t, int16_t>>);
287294
static_assert(is_defined<if_greater_size<int64_t, int16_t>>);
288295
static_assert(is_defined<if_greater_size<int64_t, int32_t>>);
289-
////static_assert(is_defined<if_greater_size<bool, int>>);
290-
////static_assert(is_defined<if_greater_size<bool, bool>>);
291-
////static_assert(is_defined<if_greater_size<int, int>>);
292-
////static_assert(is_defined<if_greater_size<int, uint32_t>>);
293-
////static_assert(is_defined<if_greater_size<int32_t, int>>);
294-
////static_assert(is_defined<if_greater_size<int8_t, int8_t>>);
295-
////static_assert(is_defined<if_greater_size<uint8_t, uint8_t>>);
296-
////static_assert(is_defined<if_greater_size<int16_t, uint16_t>>);
297-
////static_assert(is_defined<if_greater_size<uint16_t, int16_t>>);
298-
////static_assert(is_defined<if_greater_size<int32_t, uint32_t>>);
299-
////static_assert(is_defined<if_greater_size<uint32_t, int32_t>>);
300-
////static_assert(is_defined<if_greater_size<int64_t, uint64_t>>);
301-
////static_assert(is_defined<if_greater_size<uint64_t, int64_t>>);
302-
////static_assert(is_defined<if_greater_size<int, bool>>);
296+
////static_assert(!is_defined<if_greater_size<bool, bool>>);
297+
////static_assert(!is_defined<if_greater_size<int, int>>);
298+
////static_assert(!is_defined<if_greater_size<int8_t, int8_t>>);
299+
////static_assert(!is_defined<if_greater_size<uint8_t, uint8_t>>);
300+
////static_assert(!is_defined<if_greater_size<int16_t, uint16_t>>);
301+
////static_assert(!is_defined<if_greater_size<uint16_t, int16_t>>);
302+
////static_assert(!is_defined<if_greater_size<int32_t, uint32_t>>);
303+
////static_assert(!is_defined<if_greater_size<uint32_t, int32_t>>);
304+
////static_assert(!is_defined<if_greater_size<int64_t, uint64_t>>);
305+
////static_assert(!is_defined<if_greater_size<uint64_t, int64_t>>);
303306

304307
static_assert(is_defined<if_not_greater_size<bool, bool>>);
305308
static_assert(is_defined<if_not_greater_size<uint8_t, bool>>);
@@ -320,8 +323,6 @@ static_assert(is_defined<if_not_greater_size<int32_t, uint32_t>>);
320323
static_assert(is_defined<if_not_greater_size<uint32_t, int32_t>>);
321324
static_assert(is_defined<if_not_greater_size<int64_t, uint64_t>>);
322325
static_assert(is_defined<if_not_greater_size<uint64_t, int64_t>>);
323-
////static_assert(!is_defined<if_not_greater_size<bool, int>>);
324-
////static_assert(!is_defined<if_not_greater_size<int, bool>>);
325326
////static_assert(!is_defined<if_not_greater_size<int16_t, int8_t>>);
326327
////static_assert(!is_defined<if_not_greater_size<int32_t, int8_t>>);
327328
////static_assert(!is_defined<if_not_greater_size<int64_t, int8_t>>);
@@ -347,14 +348,14 @@ static_assert(is_defined<if_default_constructible<std_array<bool, 42>>>);
347348
////static_assert(!is_defined<if_default_constructible<not_default_constructible>>);
348349

349350
static_assert(is_defined<if_trivially_constructible<uint32_t>>);
350-
////static_assert(is_defined<if_trivially_constructible<std_vector<uint8_t>>>);
351+
static_assert(is_defined<if_trivially_constructible<std::array<uint8_t, 42>>>);
351352
////static_assert(!is_defined<if_trivially_constructible<std::string>>);
352-
static_assert(is_defined<if_trivially_constructible<std_array<uint8_t, 42>>>);
353+
////static_assert(!is_defined<if_trivially_constructible<std::vector<uint8_t>>>);
353354
////static_assert(!is_defined<if_trivially_constructible<not_default_constructible>>);
354355

355356
static_assert(is_defined<if_unique_object_representations<bool>>);
356357
static_assert(is_defined<if_unique_object_representations<size_t>>);
357-
//static_assert(!is_defined<if_unique_object_representations<std::string>>);
358+
////static_assert(!is_defined<if_unique_object_representations<std::string>>);
358359
////static_assert(!is_defined<if_unique_object_representations<base>>);
359360
////static_assert(!is_defined<if_unique_object_representations<derived>>);
360361

@@ -389,7 +390,7 @@ static_assert(is_defined<if_signed_integer<int>>);
389390
static_assert(is_defined<if_signed_integer<int16_t>>);
390391
static_assert(is_defined<if_signed_integer<int32_t>>);
391392
static_assert(is_defined<if_signed_integer<int64_t>>);
392-
////static_assert(is_defined<if_signed_integer<uintx>>);
393+
////static_assert(!is_defined<if_signed_integer<uintx>>);
393394
////static_assert(!is_defined<if_signed_integer<bool>>);
394395
////static_assert(!is_defined<if_signed_integer<float>>);
395396
////static_assert(!is_defined<if_signed_integer<double>>);
@@ -441,15 +442,15 @@ static_assert(is_defined<if_same_signed_integer<unsigned char, uint8_t>>);
441442
static_assert(is_defined<if_same_signed_integer<uint8_t, uint8_t>>);
442443
static_assert(is_defined<if_same_signed_integer<uint32_t, uint32_t>>);
443444
static_assert(is_defined<if_same_signed_integer<uint64_t, uint64_t>>);
444-
////static_assert(is_defined<if_same_signed_integer<bool, bool>>);
445+
////static_assert(!is_defined<if_same_signed_integer<bool, bool>>);
445446
////static_assert(!is_defined<if_same_signed_integer<float, float>>);
446447
////static_assert(!is_defined<if_same_signed_integer<double, double>>);
447448
////static_assert(!is_defined<if_same_signed_integer<base, base>>);
448449

449450
static_assert(is_defined<if_same_signed_integer<uint16_t, uint8_t>>);
450451
static_assert(is_defined<if_same_signed_integer<uint8_t, unsigned char>>);
451452
static_assert(is_defined<if_same_signed_integer<unsigned char, uint8_t>>);
452-
////static_assert(is_defined<if_same_signed_integer<int, char>>);
453+
static_assert(is_defined<if_same_signed_integer<int, char>>);
453454
////static_assert(!is_defined<if_same_signed_integer<int16_t, bool>>);
454455
////static_assert(!is_defined<if_same_signed_integer<uint16_t, bool>>);
455456
////static_assert(!is_defined<if_same_signed_integer<char, unsigned char>>);
@@ -491,8 +492,8 @@ static_assert(is_defined<if_uintx<uint512_t>>);
491492
////static_assert(!is_defined<if_uintx<base>>);
492493
////static_assert(!is_defined<if_uintx<std_array<uint8_t, 42>>>);
493494

494-
// integral integer types
495-
// bool is considered non-integral.
495+
// integral integer types
496+
// bool is considered non-integral.
496497

497498
static_assert(is_defined<if_integral<char>>);
498499
static_assert(is_defined<if_integral<int>>);
@@ -559,7 +560,7 @@ static_assert(is_defined<if_unsigned_integral_integer<uint8_t>>);
559560

560561
static_assert(is_defined<if_same_signed_integral_integer<int, signed char>>);
561562
static_assert(is_defined<if_same_signed_integral_integer<uint16_t, uint8_t>>);
562-
////static_assert(is_defined<if_same_signed_integral_integer<uintx, uint256_t>>);
563+
////static_assert(!is_defined<if_same_signed_integral_integer<uintx, uint256_t>>);
563564
////static_assert(!is_defined<if_same_signed_integral_integer<uint16_t, bool>>);
564565
////static_assert(!is_defined<if_same_signed_integral_integer<size_t, bool>>);
565566
////static_assert(!is_defined<if_same_signed_integral_integer<bool, bool>>);
@@ -588,15 +589,15 @@ static_assert(is_defined<if_same_signed_integral_integer<unsigned char, uint8_t>
588589
static_assert(is_defined<if_same_signed_integral_integer<uint8_t, uint8_t>>);
589590
static_assert(is_defined<if_same_signed_integral_integer<uint32_t, uint32_t>>);
590591
static_assert(is_defined<if_same_signed_integral_integer<uint64_t, uint64_t>>);
591-
////static_assert(is_defined<if_same_signed_integral_integer<bool, bool>>);
592+
////static_assert(!is_defined<if_same_signed_integral_integer<bool, bool>>);
592593
////static_assert(!is_defined<if_same_signed_integral_integer<float, float>>);
593594
////static_assert(!is_defined<if_same_signed_integral_integer<double, double>>);
594595
////static_assert(!is_defined<if_same_signed_integral_integer<base, base>>);
595596

596597
static_assert(is_defined<if_same_signed_integral_integer<uint16_t, uint8_t>>);
597598
static_assert(is_defined<if_same_signed_integral_integer<uint8_t, unsigned char>>);
598599
static_assert(is_defined<if_same_signed_integral_integer<unsigned char, uint8_t>>);
599-
////static_assert(is_defined<if_same_signed_integral_integer<int, char>>);
600+
static_assert(is_defined<if_same_signed_integral_integer<int, char>>);
600601
////static_assert(!is_defined<if_same_signed_integral_integer<int16_t, bool>>);
601602
////static_assert(!is_defined<if_same_signed_integral_integer<uint16_t, bool>>);
602603
////static_assert(!is_defined<if_same_signed_integral_integer<char, unsigned char>>);
@@ -606,7 +607,7 @@ static_assert(is_defined<if_not_same_signed_integral_integer<uint16_t, int>>);
606607
static_assert(is_defined<if_not_same_signed_integral_integer<size_t, int>>);
607608
static_assert(is_defined<if_not_same_signed_integral_integer<int, uint16_t>>);
608609
static_assert(is_defined<if_not_same_signed_integral_integer<int, size_t>>);
609-
////static_assert(is_defined<if_not_same_signed_integral_integer<uintx, uint256_t>>);
610+
////static_assert(!is_defined<if_not_same_signed_integral_integer<uintx, uint256_t>>);
610611
////static_assert(!is_defined<if_not_same_signed_integral_integer<int, char>>);
611612
////static_assert(!is_defined<if_not_same_signed_integral_integer<uint16_t, uint8_t>>);
612613
////static_assert(!is_defined<if_not_same_signed_integral_integer<bool, int>>);
@@ -619,8 +620,8 @@ static_assert(is_defined<if_not_same_signed_integral_integer<int, size_t>>);
619620
////static_assert(!is_defined<if_not_same_signed_integral_integer<int64_t, int>>);
620621
////static_assert(!is_defined<if_not_same_signed_integral_integer<base, int>>);
621622

622-
////static_assert(is_defined<if_big_endian_integral_integer<uint8_t>>);
623-
////static_assert(is_defined<if_little_endian_integral_integer<uint8_t>>);
623+
////static_assert(is_little_endian || is_defined<if_big_endian_integral_integer<uint8_t>>);
624+
////static_assert(is_big_endian || is_defined<if_little_endian_integral_integer<uint8_t>>);
624625

625626
////static_assert(!is_defined<if_floating_point<int>>);
626627
////static_assert(!is_defined<if_floating_point<bool>>);
@@ -647,7 +648,8 @@ static_assert(is_defined<if_integral_array<std_array<uint8_t, 0>>>);
647648
static_assert(is_defined<if_byte_insertable<std::string>>);
648649
static_assert(is_defined<if_byte_insertable<std::vector<uint8_t>>>);
649650
static_assert(is_defined<if_byte_insertable<std_vector<uint8_t>>>);
650-
////static_assert(is_defined<if_byte_insertable<std_array<uint8_t, 42>>>);
651+
////static_assert(!is_defined<if_byte_insertable<std_array<uint8_t, 42>>>);
652+
////static_assert(!is_defined<if_byte_insertable<std::array<uint8_t, 42>>>);
651653
////static_assert(!is_defined<if_byte_insertable<std::u32string>>);
652654
////static_assert(!is_defined<if_byte_insertable<std_vector<uint32_t>>>);
653655
////static_assert(!is_defined<if_byte_insertable<uint32_t>>);

‎test/typelets.cpp‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,8 @@
2121
class base {};
2222
class not_derived {};
2323
class derived : base {};
24+
class also_derived : base {};
25+
class more_derived : also_derived {};
2426

2527
// These are implementation defined.
2628
////static_assert(is_same_type<unsigned char, uint8_t>);
@@ -55,6 +57,26 @@ static_assert(!is_same_type<base, derived>);
5557
static_assert(!is_same_type<base, not_derived>);
5658
static_assert(is_same_type<decltype(is_same_type<int32_t, int32_t>), const bool>);
5759

60+
// Classes only for derivation.
61+
static_assert(!is_base_type<uint8_t, uint8_t>);
62+
static_assert(is_base_type<base, base>);
63+
static_assert(is_base_type<base, derived>);
64+
static_assert(is_base_type<base, also_derived>);
65+
static_assert(is_base_type<base, more_derived>);
66+
static_assert(!is_base_type<base, not_derived>);
67+
68+
// Classes only for derivation.
69+
static_assert(!is_common_type<uint8_t, uint8_t>);
70+
static_assert(is_common_type<base, base>);
71+
static_assert(is_common_type<base, derived>);
72+
static_assert(is_common_type<base, also_derived>);
73+
static_assert(is_common_type<base, more_derived>);
74+
static_assert(!is_common_type<base, not_derived>);
75+
static_assert(!is_common_type<more_derived, not_derived>);
76+
static_assert(!is_common_type<not_derived, more_derived>);
77+
static_assert(is_common_type<more_derived, also_derived>);
78+
static_assert(is_common_type<also_derived, more_derived>);
79+
5880
// These are implementation defined.
5981
////static_assert(is_signed<char>);
6082
////static_assert(!is_signed<wchar_t>);

0 commit comments

Comments
 (0)