From 75b10758ba116eabed730d23e957f1d69a1e3cb8 Mon Sep 17 00:00:00 2001 From: Steven Le Rouzic Date: Tue, 6 Aug 2024 00:34:57 +0200 Subject: Type traits --- asl/BUILD.bazel | 18 ++ asl/base/BUILD.bazel | 18 -- asl/base/integers.hpp | 12 - asl/base/integers_tests.cpp | 13 - asl/integers.hpp | 12 + asl/integers_tests.cpp | 13 + asl/memory/BUILD.bazel | 10 - asl/memory/layout.hpp | 6 - asl/meta.hpp | 89 +++++++ asl/meta/BUILD.bazel | 27 --- asl/meta/empty.hpp | 11 - asl/meta/empty_tests.cpp | 17 -- asl/meta/funcs.hpp | 11 - asl/meta/funcs_tests.cpp | 14 -- asl/meta/internal/quals.hpp | 16 -- asl/meta/internal/refs.hpp | 45 ---- asl/meta/internal/types.hpp | 9 - asl/meta/quals.hpp | 22 -- asl/meta/quals_tests.cpp | 51 ---- asl/meta/refs.hpp | 21 -- asl/meta/refs_tests.cpp | 33 --- asl/meta/types.hpp | 13 - asl/meta/types_tests.cpp | 10 - asl/meta_tests.cpp | 572 ++++++++++++++++++++++++++++++++++++++++++++ 24 files changed, 704 insertions(+), 359 deletions(-) create mode 100644 asl/BUILD.bazel delete mode 100644 asl/base/BUILD.bazel delete mode 100644 asl/base/integers.hpp delete mode 100644 asl/base/integers_tests.cpp create mode 100644 asl/integers.hpp create mode 100644 asl/integers_tests.cpp delete mode 100644 asl/memory/BUILD.bazel delete mode 100644 asl/memory/layout.hpp create mode 100644 asl/meta.hpp delete mode 100644 asl/meta/BUILD.bazel delete mode 100644 asl/meta/empty.hpp delete mode 100644 asl/meta/empty_tests.cpp delete mode 100644 asl/meta/funcs.hpp delete mode 100644 asl/meta/funcs_tests.cpp delete mode 100644 asl/meta/internal/quals.hpp delete mode 100644 asl/meta/internal/refs.hpp delete mode 100644 asl/meta/internal/types.hpp delete mode 100644 asl/meta/quals.hpp delete mode 100644 asl/meta/quals_tests.cpp delete mode 100644 asl/meta/refs.hpp delete mode 100644 asl/meta/refs_tests.cpp delete mode 100644 asl/meta/types.hpp delete mode 100644 asl/meta/types_tests.cpp create mode 100644 asl/meta_tests.cpp diff --git a/asl/BUILD.bazel b/asl/BUILD.bazel new file mode 100644 index 0000000..dc0aef8 --- /dev/null +++ b/asl/BUILD.bazel @@ -0,0 +1,18 @@ +cc_library( + name = "asl", + hdrs = [ + "integers.hpp", + "meta.hpp", + ], + visibility = ["//visibility:public"], +) + +[cc_test( + name = "%s_tests" % name, + srcs = [ + "%s_tests.cpp" % name, + ], + deps = [ + ":asl", + ], +) for name in ["integers", "meta"]] diff --git a/asl/base/BUILD.bazel b/asl/base/BUILD.bazel deleted file mode 100644 index 4ce905b..0000000 --- a/asl/base/BUILD.bazel +++ /dev/null @@ -1,18 +0,0 @@ -cc_library( - name = "base", - hdrs = [ - "integers.hpp", - ], - visibility = ["//visibility:public"], -) - -cc_test( - name = "integers_tests", - srcs = [ - "integers_tests.cpp", - ], - deps = [ - ":base", - ], -) - diff --git a/asl/base/integers.hpp b/asl/base/integers.hpp deleted file mode 100644 index 07fa11e..0000000 --- a/asl/base/integers.hpp +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once - -using int8_t = char; -using int16_t = short; -using int32_t = int; -using int64_t = long long; - -using uint8_t = unsigned char; -using uint16_t = unsigned short; -using uint32_t = unsigned int; -using uint64_t = unsigned long long; - diff --git a/asl/base/integers_tests.cpp b/asl/base/integers_tests.cpp deleted file mode 100644 index 587556d..0000000 --- a/asl/base/integers_tests.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include "asl/base/integers.hpp" - -static_assert(sizeof(int8_t) == 1); -static_assert(sizeof(int16_t) == 2); -static_assert(sizeof(int32_t) == 4); -static_assert(sizeof(int64_t) == 8); - -static_assert(sizeof(uint8_t) == 1); -static_assert(sizeof(uint16_t) == 2); -static_assert(sizeof(uint32_t) == 4); -static_assert(sizeof(uint64_t) == 8); - -int main() { return 0; } diff --git a/asl/integers.hpp b/asl/integers.hpp new file mode 100644 index 0000000..07fa11e --- /dev/null +++ b/asl/integers.hpp @@ -0,0 +1,12 @@ +#pragma once + +using int8_t = char; +using int16_t = short; +using int32_t = int; +using int64_t = long long; + +using uint8_t = unsigned char; +using uint16_t = unsigned short; +using uint32_t = unsigned int; +using uint64_t = unsigned long long; + diff --git a/asl/integers_tests.cpp b/asl/integers_tests.cpp new file mode 100644 index 0000000..0393a3c --- /dev/null +++ b/asl/integers_tests.cpp @@ -0,0 +1,13 @@ +#include "asl/integers.hpp" + +static_assert(sizeof(int8_t) == 1); +static_assert(sizeof(int16_t) == 2); +static_assert(sizeof(int32_t) == 4); +static_assert(sizeof(int64_t) == 8); + +static_assert(sizeof(uint8_t) == 1); +static_assert(sizeof(uint16_t) == 2); +static_assert(sizeof(uint32_t) == 4); +static_assert(sizeof(uint64_t) == 8); + +int main() { return 0; } diff --git a/asl/memory/BUILD.bazel b/asl/memory/BUILD.bazel deleted file mode 100644 index 7029496..0000000 --- a/asl/memory/BUILD.bazel +++ /dev/null @@ -1,10 +0,0 @@ -cc_library( - name = "memory", - hdrs = [ - "layout.hpp", - ], - deps = [ - "//asl/base", - ], - visibility = ["//visibility:public"], -) diff --git a/asl/memory/layout.hpp b/asl/memory/layout.hpp deleted file mode 100644 index 02ab518..0000000 --- a/asl/memory/layout.hpp +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -namespace asl { - -} // namespace asl - diff --git a/asl/meta.hpp b/asl/meta.hpp new file mode 100644 index 0000000..15f7790 --- /dev/null +++ b/asl/meta.hpp @@ -0,0 +1,89 @@ +#pragma once + +namespace asl { + +template struct integral_constant { static constexpr T value = kValue; }; +template using bool_constant = integral_constant; + +using true_type = bool_constant; +using false_type = bool_constant; + +using nullptr_t = decltype(nullptr); + +template struct un_ref { using type = T; }; +template struct un_ref { using type = T; }; +template struct un_ref { using type = T; }; +template using un_ref_t = un_ref::type; + +template struct un_const { using type = T; }; +template struct un_const { using type = T; }; +template using un_const_t = un_const::type; + +template struct un_volatile { using type = T; }; +template struct un_volatile { using type = T; }; +template using un_volatile_t = un_volatile::type; + +template using un_qual_t = un_const_t>; + +template using un_qualref_t = un_qual_t>; + +template struct _is_same_helper : false_type {}; +template struct _is_same_helper : true_type {}; + +template +concept is_same = _is_same_helper::value && _is_same_helper::value; + +template struct _is_const_helper : false_type {}; +template struct _is_const_helper : true_type {}; + +template concept is_const = _is_const_helper::value; + +template concept is_void = is_same, void>; +template concept is_nullptr = is_same, nullptr_t>; + +template concept is_integral = __is_integral(T); +template concept is_floating_point = __is_floating_point(T); +template concept is_arithmetic = is_integral || is_floating_point; + +template struct _is_array_helper : false_type {}; +template struct _is_array_helper : true_type {}; +template struct _is_array_helper : true_type {}; + +template concept is_array = _is_array_helper::value; + +template concept is_class = __is_class(T); +template concept is_union = __is_union(T); + +template concept is_enum = __is_enum(T); + +template struct _is_ptr_helper : false_type {}; +template struct _is_ptr_helper : true_type {}; + +template concept is_ptr = _is_ptr_helper>::value; + +template struct _is_ref_helper { static constexpr bool lref = false; static constexpr bool rref = false; }; +template struct _is_ref_helper { static constexpr bool lref = true; static constexpr bool rref = false; }; +template struct _is_ref_helper { static constexpr bool lref = false; static constexpr bool rref = true; }; + +template concept is_lref = _is_ref_helper::lref; +template concept is_rref = _is_ref_helper::rref; +template concept is_ref = is_lref || is_rref; + +template concept is_func = !is_const && !is_ref; + +template struct _is_member_ptr_helper : false_type {}; +template struct _is_member_ptr_helper : true_type {}; + +template struct _is_member_func_ptr_helper : false_type {}; +template struct _is_member_func_ptr_helper : bool_constant> {}; + +template concept is_member_ptr = _is_member_ptr_helper>::value; +template concept is_member_func_ptr = _is_member_func_ptr_helper>::value; +template concept is_member_object_ptr = is_member_ptr && !is_member_func_ptr; + +template concept is_fundamental = is_arithmetic || is_void || is_nullptr; +template concept is_compound = !is_fundamental; +template concept is_scalar = (is_fundamental && !is_void) || is_enum || is_ptr || is_member_ptr; +template concept is_object = is_scalar || is_array || is_class || is_union; + +} // namespace asl diff --git a/asl/meta/BUILD.bazel b/asl/meta/BUILD.bazel deleted file mode 100644 index e5b44a7..0000000 --- a/asl/meta/BUILD.bazel +++ /dev/null @@ -1,27 +0,0 @@ -cc_library( - name = "meta", - hdrs = [ - "empty.hpp", - "funcs.hpp", - "quals.hpp", - "refs.hpp", - "types.hpp", - ], - srcs = [ - "internal/quals.hpp", - "internal/refs.hpp", - "internal/types.hpp", - ], - visibility = ["//visibility:public"], -) - -[cc_test( - name = "%s_tests" % name, - srcs = [ - "%s_tests.cpp" % name, - ], - deps = [ - ":meta", - ], -) for name in ["empty", "quals", "refs", "types", "funcs"]] - diff --git a/asl/meta/empty.hpp b/asl/meta/empty.hpp deleted file mode 100644 index 9552fbd..0000000 --- a/asl/meta/empty.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#include "asl/meta/types.hpp" -#include "asl/meta/quals.hpp" - -namespace asl { - -template concept is_void = same, void>; - -} // namespace asl - diff --git a/asl/meta/empty_tests.cpp b/asl/meta/empty_tests.cpp deleted file mode 100644 index c5bf519..0000000 --- a/asl/meta/empty_tests.cpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "asl/meta/empty.hpp" - -using namespace asl; - -struct Empty {}; - -static_assert(is_void); -static_assert(is_void); -static_assert(is_void); -static_assert(is_void); -static_assert(!is_void); -static_assert(!is_void); -static_assert(!is_void); -static_assert(!is_void); - - -int main() { return 0; } diff --git a/asl/meta/funcs.hpp b/asl/meta/funcs.hpp deleted file mode 100644 index f699dac..0000000 --- a/asl/meta/funcs.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#include "asl/meta/internal/quals.hpp" -#include "asl/meta/refs.hpp" - -namespace asl { - -template concept is_func = internal::is_const::remove> && !is_any_ref; - -} // namespace asl - diff --git a/asl/meta/funcs_tests.cpp b/asl/meta/funcs_tests.cpp deleted file mode 100644 index f2f40a2..0000000 --- a/asl/meta/funcs_tests.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include "asl/meta/funcs.hpp" - -using namespace asl; - -static_assert(!is_func); -static_assert(!is_func); -static_assert(!is_func); -static_assert(!is_func); -static_assert(is_func); -static_assert(is_func); -static_assert(is_func); -static_assert(!is_func); - -int main() { return 0; } diff --git a/asl/meta/internal/quals.hpp b/asl/meta/internal/quals.hpp deleted file mode 100644 index 869cc89..0000000 --- a/asl/meta/internal/quals.hpp +++ /dev/null @@ -1,16 +0,0 @@ -#pragma once - -#include "asl/meta/types.hpp" - -namespace asl::internal { - -template struct const_helper { using add = const T; using remove = T; }; -template struct const_helper { using add = const T; using remove = T; }; - -template concept is_const = same::add>; - -template struct volatile_helper { using add = volatile T; using remove = T; }; -template struct volatile_helper { using add = volatile T; using remove = T; }; - -} // namespace asl::internal - diff --git a/asl/meta/internal/refs.hpp b/asl/meta/internal/refs.hpp deleted file mode 100644 index b21a0a1..0000000 --- a/asl/meta/internal/refs.hpp +++ /dev/null @@ -1,45 +0,0 @@ -#pragma once - -#include "asl/meta/types.hpp" - -namespace asl::internal { - -template -inline constexpr bool is_referenceable = false; - -template -inline constexpr bool is_referenceable> = true; - -template> -struct as_ref_helper { using lvalue = T; using rvalue = T; }; - -template -struct as_ref_helper { using lvalue = T&; using rvalue = T&&; }; - -template struct un_ref_helper { using type = T; }; -template struct un_ref_helper { using type = T; }; -template struct un_ref_helper { using type = T; }; - -template -struct is_ref_helper -{ - static inline constexpr bool lref = false; - static inline constexpr bool rref = false; -}; - -template -struct is_ref_helper -{ - static inline constexpr bool lref = true; - static inline constexpr bool rref = false; -}; - -template -struct is_ref_helper -{ - static inline constexpr bool lref = false; - static inline constexpr bool rref = true; -}; - -} // namespace asl::internal - diff --git a/asl/meta/internal/types.hpp b/asl/meta/internal/types.hpp deleted file mode 100644 index f635de5..0000000 --- a/asl/meta/internal/types.hpp +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once - -namespace asl::internal { - -template inline constexpr bool is_same = false; -template inline constexpr bool is_same = true; - -} // namespace asl::internal - diff --git a/asl/meta/quals.hpp b/asl/meta/quals.hpp deleted file mode 100644 index 9671043..0000000 --- a/asl/meta/quals.hpp +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include "asl/meta/types.hpp" -#include "asl/meta/funcs.hpp" -#include "asl/meta/refs.hpp" -#include "asl/meta/internal/quals.hpp" - -namespace asl { - -template concept is_const = internal::is_const; -template concept is_volatile = !is_any_ref && !is_func && same::add>; - -template using as_const_t = internal::const_helper::add; -template using un_const_t = internal::const_helper::remove; - -template using as_volatile_t = internal::volatile_helper::add; -template using un_volatile_t = internal::volatile_helper::remove; - -template using un_qual_t = un_volatile_t>; - -} // namespace asl - diff --git a/asl/meta/quals_tests.cpp b/asl/meta/quals_tests.cpp deleted file mode 100644 index 37ecc6c..0000000 --- a/asl/meta/quals_tests.cpp +++ /dev/null @@ -1,51 +0,0 @@ -#include "asl/meta/quals.hpp" -#include "asl/meta/types.hpp" - -using namespace asl; - -static_assert(!is_const); -static_assert(is_const); -static_assert(!is_const); -static_assert(is_const); - -static_assert(!is_volatile); -static_assert(!is_volatile); -static_assert(is_volatile); -static_assert(is_volatile); - -static_assert(!is_const); -static_assert(is_const); - -static_assert(is_const); -static_assert(is_const); - -static_assert(is_const); -static_assert(is_const); -static_assert(is_const); - -static_assert(!is_volatile); -static_assert(!is_volatile); - -static_assert(same, const int>); -static_assert(same, const int>); -static_assert(same, int>); -static_assert(same, int>); - -static_assert(same, const int[]>); -static_assert(same, const int[5]>); - -static_assert(same, volatile int>); -static_assert(same, volatile int>); -static_assert(same, int>); -static_assert(same, int>); - -static_assert(same, volatile int[]>); -static_assert(same, volatile int[5]>); - -static_assert(same, int>); -static_assert(same, int>); -static_assert(same, int>); -static_assert(same, int>); -static_assert(same, int>); - -int main() { return 0; } diff --git a/asl/meta/refs.hpp b/asl/meta/refs.hpp deleted file mode 100644 index b72458a..0000000 --- a/asl/meta/refs.hpp +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -#include "asl/meta/internal/refs.hpp" - -namespace asl { - -template concept referenceable = internal::is_referenceable; - -template concept is_ref = internal::is_ref_helper::lref; -template concept is_rref = internal::is_ref_helper::rref; -template concept is_any_ref = is_ref || is_rref; - -template using as_ref_t = internal::as_ref_helper::lvalue; -template using as_rref_t = internal::as_ref_helper::rvalue; - -template using un_ref_t = internal::un_ref_helper::type; - -#define AslMove(expr_) (static_cast<::asl::as_rref_t<::asl::un_ref_t>>(expr_)) -#define AslForward(expr_) (static_cast<::asl::as_rref_t>(expr_)) - -} // namespace asl diff --git a/asl/meta/refs_tests.cpp b/asl/meta/refs_tests.cpp deleted file mode 100644 index 49d4f23..0000000 --- a/asl/meta/refs_tests.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "asl/meta/refs.hpp" -#include "asl/meta/types.hpp" - -using namespace asl; - -static_assert(referenceable); -static_assert(referenceable); -static_assert(referenceable); -static_assert(!referenceable); -static_assert(referenceable); -static_assert(referenceable); -static_assert(referenceable); -static_assert(!referenceable); -static_assert(!referenceable); -static_assert(!referenceable); - -static_assert(!is_ref); -static_assert(!is_rref); -static_assert(!is_any_ref); - -static_assert(is_ref); -static_assert(!is_rref); -static_assert(is_any_ref); - -static_assert(!is_ref); -static_assert(is_rref); -static_assert(is_any_ref); - -static_assert(!is_any_ref); -static_assert(!is_any_ref); -static_assert(!is_any_ref); - -int main() { return 0; } diff --git a/asl/meta/types.hpp b/asl/meta/types.hpp deleted file mode 100644 index bfc2998..0000000 --- a/asl/meta/types.hpp +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -#include "asl/meta/internal/types.hpp" - -namespace asl { - -template using void_t = void; - -template -concept same = internal::is_same && internal::is_same; - -} // namespace asl - diff --git a/asl/meta/types_tests.cpp b/asl/meta/types_tests.cpp deleted file mode 100644 index 180ecda..0000000 --- a/asl/meta/types_tests.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#include "asl/meta/types.hpp" - -using namespace asl; - -static_assert(same); -static_assert(same); -static_assert(!same); -static_assert(!same); - -int main() { return 0; } diff --git a/asl/meta_tests.cpp b/asl/meta_tests.cpp new file mode 100644 index 0000000..f3d31f4 --- /dev/null +++ b/asl/meta_tests.cpp @@ -0,0 +1,572 @@ +#include "asl/meta.hpp" + +struct Struct { int b: 4; }; +union Union {}; + +enum Enum { EnumVariant = 0, }; +enum EnumClass { Variant = 0, }; + +static_assert(!asl::is_same); +static_assert(asl::is_same); + +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); + +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); + +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); + +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); + +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); +static_assert(asl::is_same, int>); + +static_assert(!asl::is_const); +static_assert(asl::is_const); +static_assert(!asl::is_const); +static_assert(asl::is_const); + +static_assert(asl::is_void); +static_assert(asl::is_void); +static_assert(!asl::is_void); + +static_assert(asl::is_nullptr); +static_assert(asl::is_nullptr); +static_assert(!asl::is_nullptr); +static_assert(!asl::is_nullptr); +static_assert(!asl::is_ptr); + +static_assert(asl::is_integral); +static_assert(asl::is_integral); +static_assert(asl::is_integral); +static_assert(asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); +static_assert(!asl::is_integral); + +static_assert(asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); + +static_assert(asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(asl::is_arithmetic); +static_assert(asl::is_arithmetic); +static_assert(asl::is_arithmetic); +static_assert(asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); +static_assert(!asl::is_arithmetic); + +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); +static_assert(!asl::is_fundamental); + +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(asl::is_array); +static_assert(asl::is_array); +static_assert(asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(asl::is_array); +static_assert(asl::is_array); +static_assert(asl::is_array); +static_assert(asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); +static_assert(!asl::is_array); + +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(asl::is_class); +static_assert(asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); +static_assert(!asl::is_class); + +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(asl::is_union); +static_assert(asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); +static_assert(!asl::is_union); + +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(asl::is_enum); +static_assert(asl::is_enum); +static_assert(!asl::is_enum); +static_assert(!asl::is_enum); +static_assert(asl::is_enum); +static_assert(asl::is_enum); + +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); +static_assert(!asl::is_ptr); + +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(asl::is_ref); +static_assert(asl::is_ref); +static_assert(asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); +static_assert(!asl::is_ref); + +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(asl::is_lref); +static_assert(asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); +static_assert(!asl::is_lref); + +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); +static_assert(!asl::is_rref); + +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(asl::is_member_ptr); +static_assert(asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); +static_assert(!asl::is_member_ptr); + +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); +static_assert(!asl::is_member_object_ptr); + +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); +static_assert(!asl::is_member_func_ptr); + +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(!asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); +static_assert(asl::is_compound); + +static_assert(asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(!asl::is_scalar); +static_assert(asl::is_scalar); +static_assert(asl::is_scalar); + +static_assert(asl::is_object); +static_assert(!asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(!asl::is_object); +static_assert(!asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(!asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(!asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(!asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); +static_assert(asl::is_object); + +int main() { return 0; } + -- cgit