From 8ae5c2b21dc7f792be1a6b10fc245d82ba501e21 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Wed, 3 Apr 2024 16:18:23 -0400 Subject: [PATCH] cpp-common/vendor: add copy of wise_enum Add a copy of wise_enum, a smart enum library that allows doing cool things like getting the number of enumerators of an enum, iterating on enumerators, and converting enumerators to string while effectively keeping vanilla `enum`/`enum class` behind the scenes (no enum-like class). The version is 3.1.0, which corresponds to the git tag `3.1.0`, which corresponds to this git commit: https://github.com/quicknir/wise_enum/commit/34ac79f7ea2658a148359ce82508cc9301e31dd3 Change-Id: I9b92d5cd012dee427cdd725c17eeae9f2a529cb0 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/12242 Tested-by: jenkins Reviewed-by: Philippe Proulx --- .reuse/dep5 | 5 + CONTRIBUTING.adoc | 3 + README.adoc | 1 + src/Makefile.am | 7 +- src/cpp-common/vendor/wise-enum/optional.h | 82 ++++ .../vendor/wise-enum/optional_common.h | 23 + src/cpp-common/vendor/wise-enum/wise_enum.h | 108 +++++ .../vendor/wise-enum/wise_enum_detail.h | 208 +++++++++ .../vendor/wise-enum/wise_enum_generated.h | 406 ++++++++++++++++++ 9 files changed, 842 insertions(+), 1 deletion(-) create mode 100644 src/cpp-common/vendor/wise-enum/optional.h create mode 100644 src/cpp-common/vendor/wise-enum/optional_common.h create mode 100644 src/cpp-common/vendor/wise-enum/wise_enum.h create mode 100644 src/cpp-common/vendor/wise-enum/wise_enum_detail.h create mode 100644 src/cpp-common/vendor/wise-enum/wise_enum_generated.h diff --git a/.reuse/dep5 b/.reuse/dep5 index f880aacc..2f272d84 100644 --- a/.reuse/dep5 +++ b/.reuse/dep5 @@ -5,3 +5,8 @@ Files: src/cpp-common/vendor/fmt/*.cc Copyright: 2012 - present, Victor Zverovich License: MIT + +Files: + src/cpp-common/vendor/wise-enum/*.h +Copyright: 2017 - present, Nir Friedman +License: BSL-1.0 diff --git a/CONTRIBUTING.adoc b/CONTRIBUTING.adoc index 35f4923c..37105c6c 100644 --- a/CONTRIBUTING.adoc +++ b/CONTRIBUTING.adoc @@ -1821,6 +1821,9 @@ IMPORTANT: Use the symbols of `src/cpp-common/bt2s/span.hpp`, under the IMPORTANT: Use the symbols of `src/cpp-common/bt2s/string-view.hpp`, under the `bt2s` namespace, instead of using this directly. +`wise_enum`:: + https://github.com/quicknir/wise_enum[wise_enum]. + === Automake/Libtool requirements To add a {cpp} source file to a part of the project, use the `.cpp` diff --git a/README.adoc b/README.adoc index b47dd1d8..5c7c48e4 100644 --- a/README.adoc +++ b/README.adoc @@ -138,6 +138,7 @@ embedded into the {bt2} source tree: * https://github.com/martinmoene/optional-lite[optional lite] * https://github.com/martinmoene/span-lite[span lite] * https://github.com/martinmoene/string-view-lite[string_view lite] +* https://github.com/quicknir/wise_enum[wise_enum] * https://github.com/wonder-mice/zf_log[zf_log] ==== diff --git a/src/Makefile.am b/src/Makefile.am index 4fbca755..14ff26f9 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -183,7 +183,12 @@ cpp_common_libcpp_common_la_SOURCES = \ cpp-common/vendor/nlohmann/json.hpp \ cpp-common/vendor/optional-lite/optional.hpp \ cpp-common/vendor/span-lite/span.hpp \ - cpp-common/vendor/string-view-lite/string_view.hpp + cpp-common/vendor/string-view-lite/string_view.hpp \ + cpp-common/vendor/wise-enum/optional.h \ + cpp-common/vendor/wise-enum/optional_common.h \ + cpp-common/vendor/wise-enum/wise_enum.h \ + cpp-common/vendor/wise-enum/wise_enum_detail.h \ + cpp-common/vendor/wise-enum/wise_enum_generated.h cpp_common_vendor_fmt_libfmt_la_SOURCES = \ cpp-common/vendor/fmt/args.h \ diff --git a/src/cpp-common/vendor/wise-enum/optional.h b/src/cpp-common/vendor/wise-enum/optional.h new file mode 100644 index 00000000..6b0dab14 --- /dev/null +++ b/src/cpp-common/vendor/wise-enum/optional.h @@ -0,0 +1,82 @@ +#pragma once + +#include "optional_common.h" + +#include +#include + +#if __cplusplus == 201103 +#define WISE_ENUM_CONSTEXPR_14 +#else +#define WISE_ENUM_CONSTEXPR_14 constexpr +#endif + +namespace wise_enum { + +/* A simple, *forward* compatible optional implementation. That is, it does not + * provide the full std::optional interface, but all the interface it does + * provide is found on std::optional, so it should not be a breaking change to + * upgrade to std::optional. + */ +template +class optional { +public: + static_assert(std::is_enum::value, + "wise enum optional is only for enum types"); + optional() = default; + optional(T t) : m_t(t), m_active(true) {} + + WISE_ENUM_CONSTEXPR_14 T &operator*() & { return m_t; } + constexpr const T &operator*() const & { return m_t; } + WISE_ENUM_CONSTEXPR_14 T &&operator*() && { return m_t; } + constexpr const T &&operator*() const && { return m_t; } + + constexpr explicit operator bool() const noexcept { return m_active; } + constexpr bool has_value() const noexcept { return m_active; } + + WISE_ENUM_CONSTEXPR_14 T &value() & { + if (m_active) + return m_t; + else + WISE_ENUM_OPTIONAL_BAD_ACCESS; + } + WISE_ENUM_CONSTEXPR_14 const T &value() const & { + if (m_active) + return m_t; + else + WISE_ENUM_OPTIONAL_BAD_ACCESS; + } + + WISE_ENUM_CONSTEXPR_14 T &&value() && { + if (m_active) + return m_t; + else + WISE_ENUM_OPTIONAL_BAD_ACCESS; + } + WISE_ENUM_CONSTEXPR_14 const T &&value() const && { + if (m_active) + return m_t; + else + WISE_ENUM_OPTIONAL_BAD_ACCESS; + } + + template + WISE_ENUM_CONSTEXPR_14 T value_or(U &&u) { + if (m_active) + return m_t; + else + return std::forward(u); + } + + void reset() noexcept { m_active = false; } + + optional(const optional &other) = default; + optional(optional &&other) = default; + optional &operator=(const optional &other) = default; + optional &operator=(optional &&other) = default; + +private: + T m_t; + bool m_active = false; +}; +} // namespace wise_enum diff --git a/src/cpp-common/vendor/wise-enum/optional_common.h b/src/cpp-common/vendor/wise-enum/optional_common.h new file mode 100644 index 00000000..c8f7b4f2 --- /dev/null +++ b/src/cpp-common/vendor/wise-enum/optional_common.h @@ -0,0 +1,23 @@ +#pragma once + +#ifdef WISE_ENUM_NO_EXCEPT + +#include +#define WISE_ENUM_OPTIONAL_BAD_ACCESS std::abort() + +#else + +#include + +namespace wise_enum { + +struct bad_optional_access : std::exception { + const char *what() const noexcept override { + return "Error, attempt to access valueless optional!"; + } +}; +} // namespace wise_enum + +#define WISE_ENUM_OPTIONAL_BAD_ACCESS throw bad_optional_access{} + +#endif diff --git a/src/cpp-common/vendor/wise-enum/wise_enum.h b/src/cpp-common/vendor/wise-enum/wise_enum.h new file mode 100644 index 00000000..db50027d --- /dev/null +++ b/src/cpp-common/vendor/wise-enum/wise_enum.h @@ -0,0 +1,108 @@ +#pragma once + +#include "wise_enum_detail.h" +#include "wise_enum_generated.h" + +#include +#include +#include +#include + +/* + Macro interface + + The first argument to any macro enum is either the name of the enum, or a + parenthesized pair, (name, storage). The first form results in unfixed + underlying type for the enum, while the second form defines it explicitly. + After that, the macros take a variadic enumerator list. Each entry in the list + can be either a legal identifier name, or it can be a parenthesized pair where + the first entry is the identifier and the second entry is the initializer. + + Usage notes: + - A semi-colon after the macro invocation is not necessary, and your + compiler may warn for it +*/ + +// Declare an enum at namespace scope +#define WISE_ENUM(name, ...) WISE_ENUM_IMPL(enum, name, , __VA_ARGS__) + +// Declare an enum class at namespace scope +#define WISE_ENUM_CLASS(name, ...) \ + WISE_ENUM_IMPL(enum class, name, , __VA_ARGS__) + +// Declare an enum at class scope +#define WISE_ENUM_MEMBER(name, ...) \ + WISE_ENUM_IMPL(enum, name, friend, __VA_ARGS__) + +// Declare an enum class at class scope +#define WISE_ENUM_CLASS_MEMBER(name, ...) \ + WISE_ENUM_IMPL(enum class, name, friend, __VA_ARGS__) + +/* + Adapt an existing enum into the wise enum API. This macro must be used at + global scope. The first argument must be the name of the enum (qualified), + followed by all the enumerators of the enum. +*/ +#define WISE_ENUM_ADAPT(name, ...) WISE_ENUM_IMPL_ADAPT(name, __VA_ARGS__) + +namespace wise_enum { + +// Returns the string representation of an enumerator +template +constexpr string_type to_string(T t) { + return wise_enum_detail_to_string(t, detail::Tag{}); +} + +// Enumerators trait class. Each value is also available as a template variable +// for C++14 and on +template +struct enumerators { + // For a given wise enum type, this variable allows iteration over enumerators + // and their string names in the declared order. Each iterated object is a + // struct with members { T value; string_type name; } + static constexpr decltype(wise_enum_detail_array(detail::Tag{})) range = + wise_enum_detail_array(detail::Tag{}); + + // This variable is equal to the number of enumerators for the wise enum type. + static constexpr std::size_t size = range.size(); +}; + +template +constexpr decltype( + wise_enum_detail_array(detail::Tag{})) enumerators::range; + +template +constexpr std::size_t enumerators::size; + +#if __cplusplus >= 201402 +template +constexpr auto &range = enumerators::range; + +template +constexpr std::size_t size = enumerators::size; +#endif + +// A type trait; this allows checking if a type is a wise_enum in generic code +template +using is_wise_enum = detail::is_wise_enum; + +#if __cplusplus >= 201402 +template +static constexpr bool is_wise_enum_v = is_wise_enum::value; +#endif + +// Converts a string literal into a wise enum. Returns an optional; if no +// enumerator has name matching the string, the optional is returned empty. +template +WISE_ENUM_CONSTEXPR_14 optional_type from_string(string_type s) { + auto it = + std::find_if(enumerators::range.begin(), enumerators::range.end(), + [=](const detail::value_and_name &x) { + return ::wise_enum::detail::compare(x.name, s); + }); + if (it == enumerators::range.end()) + return {}; + + return it->value; +} +} // namespace wise_enum diff --git a/src/cpp-common/vendor/wise-enum/wise_enum_detail.h b/src/cpp-common/vendor/wise-enum/wise_enum_detail.h new file mode 100644 index 00000000..1accbe78 --- /dev/null +++ b/src/cpp-common/vendor/wise-enum/wise_enum_detail.h @@ -0,0 +1,208 @@ +#pragma once + +#include +#include +#include + +// optional type needed for interface +#ifndef WISE_ENUM_OPTIONAL_TYPE +#if __cplusplus >= 201703L +#include +namespace wise_enum { +template +using optional_type = std::optional; +} +#else +#include "optional.h" +namespace wise_enum { +template +using optional_type = wise_enum::optional; +} +#endif +#else +namespace wise_enum { +template +using optional_type = WISE_ENUM_OPTIONAL_TYPE; +} +#endif + +// Choice of string_view if type defined, otherwise use string literal +#ifndef WISE_ENUM_STRING_TYPE +#if __cplusplus >= 201703L +#include +namespace wise_enum { +using string_type = std::string_view; +} +#else +namespace wise_enum { +using string_type = const char *; +} +#endif +#else +namespace wise_enum { +using string_type = WISE_ENUM_STRING_TYPE; +} +#endif + +#if __cplusplus == 201103 +#define WISE_ENUM_CONSTEXPR_14 +#else +#define WISE_ENUM_CONSTEXPR_14 constexpr +#endif + +namespace wise_enum { +namespace detail { + +template +struct value_and_name { + T value; + string_type name; +}; + +template +struct Tag {}; + +constexpr void wise_enum_detail_array(...); + +template +struct is_wise_enum + : std::integral_constant< + bool, !std::is_same{}))>::value> {}; + +WISE_ENUM_CONSTEXPR_14 inline int strcmp(const char *s1, const char *s2) { + while (*s1 && (*s1 == *s2)) + s1++, s2++; + if (*s1 < *s2) { + return -1; + } + if (*s1 > *s2) { + return 1; + } else { + return 0; + } +} + +WISE_ENUM_CONSTEXPR_14 inline bool compare(const char *s1, const char *s2) { + return strcmp(s1, s2) == 0; +} + +template ::value>::type> +WISE_ENUM_CONSTEXPR_14 bool compare(U u1, U u2) { + return u1 == u2; +} +} // namespace detail +} // namespace wise_enum + + +// Needed for expansion of variadic macro arguments in MSVC +// MSVC expands __VA_ARGS__ after passing it, while gcc expands it before +#define WISE_ENUM_IMPL_EXPAND(x) x + +#define WISE_ENUM_IMPL_NARG(...) \ + WISE_ENUM_IMPL_NARG_(__VA_ARGS__, WISE_ENUM_IMPL_RSEQ_N()) +#define WISE_ENUM_IMPL_NARG_(...) WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_ARG_N(__VA_ARGS__)) + +// ARG_N and RSEQ_N defined in wise_enum_generated.h + +// Building blocks; credit to: +// https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms + +#define WISE_ENUM_IMPL_COMMA() , +#define WISE_ENUM_IMPL_NOTHING() + +#define WISE_ENUM_IMPL_CAT(a, ...) WISE_ENUM_IMPL_PRIMITIVE_CAT(a, __VA_ARGS__) +#define WISE_ENUM_IMPL_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__ + +#define WISE_ENUM_IMPL_XSTR(s) #s +#define WISE_ENUM_IMPL_STR(s) WISE_ENUM_IMPL_XSTR(s) + +#define WISE_ENUM_IMPL_IIF(c) WISE_ENUM_IMPL_CAT(WISE_ENUM_IMPL_IIF_, c) +#define WISE_ENUM_IMPL_IIF_0(t, f) f +#define WISE_ENUM_IMPL_IIF_1(t, f) t + +#define WISE_ENUM_IMPL_CHECK_N(x, n, ...) n +#define WISE_ENUM_IMPL_CHECK(...) \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_CHECK_N(__VA_ARGS__, 0, )) +#define WISE_ENUM_IMPL_PROBE(x) x, 1, + +#define WISE_ENUM_IMPL_IS_PAREN(x) \ + WISE_ENUM_IMPL_CHECK(WISE_ENUM_IMPL_IS_PAREN_PROBE x) +#define WISE_ENUM_IMPL_IS_PAREN_PROBE(...) WISE_ENUM_IMPL_PROBE(~) + +#define WISE_ENUM_IMPL_FIRST_ARG(x, ...) x + +#define WISE_ENUM_IMPL_ONLY_OR_FIRST(x) \ + WISE_ENUM_IMPL_IIF(WISE_ENUM_IMPL_IS_PAREN(x)) \ + (WISE_ENUM_IMPL_FIRST_ARG x, x) + +// Use building blocks to conditionally process enumerators; they can either be +// just an identifier, or (identifier, value) +#define WISE_ENUM_IMPL_ENUM_INIT_2(x, ...) x = __VA_ARGS__ +#define WISE_ENUM_IMPL_ENUM_INIT(name, x) \ + WISE_ENUM_IMPL_IIF(WISE_ENUM_IMPL_IS_PAREN(x)) \ + (WISE_ENUM_IMPL_ENUM_INIT_2 x, x) + +#define WISE_ENUM_IMPL_ENUM_STR(x) \ + WISE_ENUM_IMPL_STR(WISE_ENUM_IMPL_ONLY_OR_FIRST(x)) + +#define WISE_ENUM_IMPL_DESC_PAIR(name, x) \ + { name::WISE_ENUM_IMPL_ONLY_OR_FIRST(x), WISE_ENUM_IMPL_ENUM_STR(x) } + +#define WISE_ENUM_IMPL_SWITCH_CASE(name, x) \ + case name::WISE_ENUM_IMPL_ONLY_OR_FIRST(x): \ + return WISE_ENUM_IMPL_ENUM_STR(x); + +#define WISE_ENUM_IMPL_STORAGE_2(x, y) y + +#define WISE_ENUM_IMPL_STORAGE(x) \ + WISE_ENUM_IMPL_IIF(WISE_ENUM_IMPL_IS_PAREN(x)) \ + ( : WISE_ENUM_IMPL_STORAGE_2 x, ) + +#define WISE_ENUM_IMPL(type, name_storage, friendly, ...) \ + WISE_ENUM_IMPL_2(type, WISE_ENUM_IMPL_ONLY_OR_FIRST(name_storage), \ + WISE_ENUM_IMPL_STORAGE(name_storage), friendly, \ + WISE_ENUM_IMPL_NARG(__VA_ARGS__), __VA_ARGS__) + +#define WISE_ENUM_IMPL_2(type, name, storage, friendly, num_enums, ...) \ + WISE_ENUM_IMPL_3(type, name, storage, friendly, num_enums, \ + WISE_ENUM_IMPL_CAT(WISE_ENUM_IMPL_LOOP_, num_enums), \ + __VA_ARGS__) + + +#define WISE_ENUM_IMPL_3(type, name, storage, friendly, num_enums, loop, ...) \ + type name storage{ \ + WISE_ENUM_IMPL_EXPAND(loop(WISE_ENUM_IMPL_ENUM_INIT, _, \ + WISE_ENUM_IMPL_COMMA, __VA_ARGS__))}; \ + WISE_ENUM_IMPL_ADAPT_3(name, friendly, num_enums, loop, __VA_ARGS__) + +#define WISE_ENUM_IMPL_ADAPT(name, ...) \ + namespace wise_enum { \ + namespace detail { \ + WISE_ENUM_IMPL_ADAPT_2(name, WISE_ENUM_IMPL_NARG(__VA_ARGS__), __VA_ARGS__) \ + } \ + } + +#define WISE_ENUM_IMPL_ADAPT_2(name, num_enums, ...) \ + WISE_ENUM_IMPL_ADAPT_3(name, , num_enums, \ + WISE_ENUM_IMPL_CAT(WISE_ENUM_IMPL_LOOP_, num_enums), \ + __VA_ARGS__) + +#define WISE_ENUM_IMPL_ADAPT_3(name, friendly, num_enums, loop, ...) \ + friendly constexpr std::array<::wise_enum::detail::value_and_name, \ + num_enums> \ + wise_enum_detail_array(::wise_enum::detail::Tag) { \ + return {{WISE_ENUM_IMPL_EXPAND(loop(WISE_ENUM_IMPL_DESC_PAIR, name, \ + WISE_ENUM_IMPL_COMMA, __VA_ARGS__))}}; \ + } \ + \ + template \ + friendly WISE_ENUM_CONSTEXPR_14 ::wise_enum::string_type \ + wise_enum_detail_to_string(T e, ::wise_enum::detail::Tag) { \ + switch (e) { \ + WISE_ENUM_IMPL_EXPAND(loop(WISE_ENUM_IMPL_SWITCH_CASE, name, \ + WISE_ENUM_IMPL_NOTHING, __VA_ARGS__)) \ + } \ + return {}; \ + } diff --git a/src/cpp-common/vendor/wise-enum/wise_enum_generated.h b/src/cpp-common/vendor/wise-enum/wise_enum_generated.h new file mode 100644 index 00000000..f83c8aef --- /dev/null +++ b/src/cpp-common/vendor/wise-enum/wise_enum_generated.h @@ -0,0 +1,406 @@ +#define WISE_ENUM_IMPL_ARG_N( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ + _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \ + _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \ + _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ + _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \ + _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \ + _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, \ + _71, _72, _73, _74, _75, _76, _77, _78, _79, _80, \ + _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, \ + _91, _92, _93, _94, _95, _96, _97, _98, _99, _100, \ + _101, _102, _103, _104, _105, _106, _107, _108, _109, _110, \ + _111, _112, _113, _114, _115, _116, _117, _118, _119, _120, \ + _121, _122, _123, _124, _125, N, ... \ + ) \ + N \ + +#define WISE_ENUM_IMPL_RSEQ_N() \ + 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, \ + 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, \ + 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, \ + 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, \ + 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, \ + 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, \ + 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, \ + 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, \ + 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, \ + 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, \ + 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, \ + 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, \ + 5, 4, 3, 2, 1, 0 \ + +#define WISE_ENUM_IMPL_LOOP_1(M, C, D, x) M(C, x) + +#define WISE_ENUM_IMPL_LOOP_2(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_1(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_3(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_2(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_4(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_3(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_5(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_4(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_6(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_5(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_7(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_6(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_8(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_7(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_9(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_8(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_10(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_9(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_11(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_10(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_12(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_11(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_13(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_12(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_14(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_13(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_15(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_14(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_16(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_15(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_17(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_16(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_18(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_17(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_19(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_18(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_20(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_19(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_21(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_20(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_22(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_21(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_23(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_22(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_24(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_23(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_25(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_24(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_26(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_25(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_27(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_26(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_28(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_27(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_29(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_28(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_30(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_29(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_31(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_30(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_32(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_31(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_33(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_32(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_34(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_33(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_35(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_34(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_36(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_35(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_37(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_36(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_38(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_37(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_39(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_38(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_40(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_39(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_41(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_40(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_42(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_41(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_43(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_42(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_44(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_43(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_45(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_44(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_46(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_45(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_47(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_46(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_48(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_47(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_49(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_48(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_50(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_49(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_51(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_50(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_52(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_51(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_53(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_52(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_54(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_53(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_55(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_54(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_56(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_55(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_57(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_56(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_58(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_57(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_59(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_58(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_60(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_59(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_61(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_60(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_62(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_61(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_63(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_62(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_64(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_63(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_65(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_64(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_66(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_65(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_67(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_66(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_68(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_67(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_69(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_68(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_70(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_69(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_71(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_70(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_72(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_71(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_73(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_72(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_74(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_73(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_75(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_74(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_76(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_75(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_77(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_76(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_78(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_77(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_79(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_78(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_80(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_79(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_81(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_80(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_82(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_81(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_83(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_82(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_84(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_83(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_85(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_84(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_86(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_85(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_87(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_86(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_88(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_87(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_89(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_88(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_90(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_89(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_91(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_90(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_92(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_91(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_93(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_92(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_94(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_93(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_95(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_94(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_96(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_95(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_97(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_96(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_98(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_97(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_99(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_98(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_100(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_99(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_101(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_100(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_102(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_101(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_103(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_102(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_104(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_103(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_105(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_104(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_106(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_105(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_107(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_106(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_108(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_107(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_109(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_108(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_110(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_109(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_111(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_110(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_112(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_111(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_113(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_112(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_114(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_113(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_115(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_114(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_116(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_115(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_117(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_116(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_118(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_117(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_119(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_118(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_120(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_119(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_121(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_120(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_122(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_121(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_123(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_122(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_124(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_123(M, C, D, __VA_ARGS__)) + +#define WISE_ENUM_IMPL_LOOP_125(M, C, D, x, ...) M(C, x) D() \ + WISE_ENUM_IMPL_EXPAND(WISE_ENUM_IMPL_LOOP_124(M, C, D, __VA_ARGS__)) + -- 2.34.1