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 <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/12242
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>

diff --git a/.reuse/dep5 b/.reuse/dep5
index f880aacc89c0c2928f823ceb53b4b8ba90b98908..2f272d84e58d8957e8e2e61fb2a7483968e206ad 100644 (file)
--- 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 35f4923c964e8e0a2231474242940ba8349922b9..37105c6c696af503273b5068d8d77051ea290ede 100644 (file)
--- 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 b47dd1d846ccba2da3ba5173cd6cea8e7db183ae..5c7c48e46b2cce3d6692d77d1c86c01c5ee4e737 100644 (file)
--- 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 4fbca7551d5eacf2c1a91c61f4ae0c411262ac5f..14ff26f9708c113dc2cc9a411c1d417749f9ca3f 100644 (file)
--- 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 (file)
index 0000000..6b0dab1
--- /dev/null
+++ b/src/cpp-common/vendor/wise-enum/optional.h
@@ -0,0 +1,82 @@
+#pragma once
+
+#include "optional_common.h"
+
+#include <stdexcept>
+#include <type_traits>
+
+#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 T>
+class optional {
+public:
+  static_assert(std::is_enum<T>::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 <class U>
+  WISE_ENUM_CONSTEXPR_14 T value_or(U &&u) {
+    if (m_active)
+      return m_t;
+    else
+      return std::forward<U>(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 (file)
index 0000000..c8f7b4f
--- /dev/null
+++ b/src/cpp-common/vendor/wise-enum/optional_common.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef WISE_ENUM_NO_EXCEPT
+
+#include <cstdlib>
+#define WISE_ENUM_OPTIONAL_BAD_ACCESS std::abort()
+
+#else
+
+#include <stdexcept>
+
+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 (file)
index 0000000..db50027
--- /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 <algorithm>
+#include <array>
+#include <type_traits>
+#include <utility>
+
+/*
+ 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 <class T>
+constexpr string_type to_string(T t) {
+  return wise_enum_detail_to_string(t, detail::Tag<T>{});
+}
+
+// Enumerators trait class. Each value is also available as a template variable
+// for C++14 and on
+template <class T>
+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<T>{})) range =
+      wise_enum_detail_array(detail::Tag<T>{});
+
+  // This variable is equal to the number of enumerators for the wise enum type.
+  static constexpr std::size_t size = range.size();
+};
+
+template <class T>
+constexpr decltype(
+    wise_enum_detail_array(detail::Tag<T>{})) enumerators<T>::range;
+
+template <class T>
+constexpr std::size_t enumerators<T>::size;
+
+#if __cplusplus >= 201402
+template <class T>
+constexpr auto &range = enumerators<T>::range;
+
+template <class T>
+constexpr std::size_t size = enumerators<T>::size;
+#endif
+
+// A type trait; this allows checking if a type is a wise_enum in generic code
+template <class T>
+using is_wise_enum = detail::is_wise_enum<T>;
+
+#if __cplusplus >= 201402
+template <class T>
+static constexpr bool is_wise_enum_v = is_wise_enum<T>::value;
+#endif
+
+// Converts a string literal into a wise enum. Returns an optional<T>; if no
+// enumerator has name matching the string, the optional is returned empty.
+template <class T>
+WISE_ENUM_CONSTEXPR_14 optional_type<T> from_string(string_type s) {
+  auto it =
+      std::find_if(enumerators<T>::range.begin(), enumerators<T>::range.end(),
+                   [=](const detail::value_and_name<T> &x) {
+                     return ::wise_enum::detail::compare(x.name, s);
+                   });
+  if (it == enumerators<T>::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 (file)
index 0000000..1accbe7
--- /dev/null
+++ b/src/cpp-common/vendor/wise-enum/wise_enum_detail.h
@@ -0,0 +1,208 @@
+#pragma once
+
+#include <array>
+#include <type_traits>
+#include <utility>
+
+// optional type needed for interface
+#ifndef WISE_ENUM_OPTIONAL_TYPE
+#if __cplusplus >= 201703L
+#include <optional>
+namespace wise_enum {
+template <class T>
+using optional_type = std::optional<T>;
+}
+#else
+#include "optional.h"
+namespace wise_enum {
+template <class T>
+using optional_type = wise_enum::optional<T>;
+}
+#endif
+#else
+namespace wise_enum {
+template <class T>
+using optional_type = WISE_ENUM_OPTIONAL_TYPE<T>;
+}
+#endif
+
+// Choice of string_view if type defined, otherwise use string literal
+#ifndef WISE_ENUM_STRING_TYPE
+#if __cplusplus >= 201703L
+#include <string_view>
+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 <class T>
+struct value_and_name {
+  T value;
+  string_type name;
+};
+
+template <class T>
+struct Tag {};
+
+constexpr void wise_enum_detail_array(...);
+
+template <class T>
+struct is_wise_enum
+    : std::integral_constant<
+          bool, !std::is_same<void, decltype(wise_enum_detail_array(
+                                        Tag<T>{}))>::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 <class U, class = typename std::enable_if<
+                       !std::is_same<U, const char *>::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<name>,     \
+                                num_enums>                                     \
+  wise_enum_detail_array(::wise_enum::detail::Tag<name>) {                     \
+    return {{WISE_ENUM_IMPL_EXPAND(loop(WISE_ENUM_IMPL_DESC_PAIR, name,        \
+                  WISE_ENUM_IMPL_COMMA, __VA_ARGS__))}};                       \
+  }                                                                            \
+                                                                               \
+  template <class T>                                                           \
+  friendly WISE_ENUM_CONSTEXPR_14 ::wise_enum::string_type                     \
+  wise_enum_detail_to_string(T e, ::wise_enum::detail::Tag<name>) {            \
+    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 (file)
index 0000000..f83c8ae
--- /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__))
+