mirror of
https://github.com/Neargye/magic_enum.git
synced 2026-01-09 23:34:23 +00:00
Enum switch (#168)
This commit is contained in:
Bela Schaum
GitHub
parent
542aacea41
commit
64bedded2a
6 changed files with 288 additions and 11 deletions
|
|
@ -259,7 +259,7 @@ class case_insensitive {
|
|||
|
||||
public:
|
||||
template <typename L, typename R>
|
||||
constexpr auto operator()([[maybe_unused]] L lhs, [[maybe_unused]] R rhs) noexcept -> std::enable_if_t<std::is_same_v<std::decay_t<L>, char> && std::is_same_v<std::decay_t<R>, char>, bool> {
|
||||
constexpr auto operator()([[maybe_unused]] L lhs, [[maybe_unused]] R rhs) const noexcept -> std::enable_if_t<std::is_same_v<std::decay_t<L>, char> && std::is_same_v<std::decay_t<R>, char>, bool> {
|
||||
#if defined(MAGIC_ENUM_ENABLE_NONASCII)
|
||||
static_assert(always_false_v<L, R>, "magic_enum::case_insensitive not supported Non-ASCII feature.");
|
||||
return false;
|
||||
|
|
@ -807,16 +807,26 @@ constexpr bool no_duplicate() {
|
|||
T(192)T(193)T(194)T(195)T(196)T(197)T(198)T(199)T(200)T(201)T(202)T(203)T(204)T(205)T(206)T(207)T(208)T(209)T(210)T(211)T(212)T(213)T(214)T(215)T(216)T(217)T(218)T(219)T(220)T(221)T(222)T(223) \
|
||||
T(224)T(225)T(226)T(227)T(228)T(229)T(230)T(231)T(232)T(233)T(234)T(235)T(236)T(237)T(238)T(239)T(240)T(241)T(242)T(243)T(244)T(245)T(246)T(247)T(248)T(249)T(250)T(251)T(252)T(253)T(254)T(255)
|
||||
|
||||
#define MAGIC_ENUM_CASE(val) \
|
||||
case cases[val]: \
|
||||
if constexpr ((val) + page < size) { \
|
||||
if (!pred(values[val + page], searched)) \
|
||||
break; \
|
||||
if constexpr (call_v == case_call_t::index && std::is_invocable_r_v<result_t, Lambda, std::integral_constant<std::size_t, val + page>>) \
|
||||
return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), std::integral_constant<std::size_t, val + page>{}); \
|
||||
else if constexpr (call_v == case_call_t::value && std::is_invocable_r_v<result_t, Lambda, std::integral_constant<value_t, values[val + page]>>) \
|
||||
return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), std::integral_constant<value_t, values[val + page]>{}); \
|
||||
break; \
|
||||
#define MAGIC_ENUM_CASE(val) \
|
||||
case cases[val]: \
|
||||
if constexpr ((val) + page < size) { \
|
||||
if (!pred(values[val + page], searched)) { \
|
||||
break; \
|
||||
} \
|
||||
if constexpr (call_v == case_call_t::index) { \
|
||||
if constexpr (std::is_invocable_r_v<result_t, Lambda, std::integral_constant<std::size_t, val + page>>) { \
|
||||
return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), std::integral_constant<std::size_t, val + page>{}); \
|
||||
} else if constexpr (std::is_invocable_v<Lambda, std::integral_constant<std::size_t, val + page>>) { \
|
||||
assert(false && "wrong result type"); \
|
||||
} \
|
||||
} else if constexpr (call_v == case_call_t::value) { \
|
||||
if constexpr (std::is_invocable_r_v<result_t, Lambda, std::integral_constant<value_t, values[val + page]>>) { \
|
||||
return detail::invoke_r<result_t>(std::forward<Lambda>(lambda), std::integral_constant<value_t, values[val + page]>{}); \
|
||||
} else if constexpr (std::is_invocable_r_v<result_t, Lambda, std::integral_constant<value_t, values[val + page]>>) { \
|
||||
assert(false && "wrong result type"); \
|
||||
} \
|
||||
} \
|
||||
break; \
|
||||
} else [[fallthrough]];
|
||||
|
||||
template <auto* globValues,
|
||||
|
|
@ -851,6 +861,22 @@ constexpr std::invoke_result_t<ResultGetterType> constexpr_switch(
|
|||
#undef MAGIC_ENUM_FOR_EACH_256
|
||||
#undef MAGIC_ENUM_CASE
|
||||
|
||||
template<typename E, typename Lambda, std::size_t ... Ix>
|
||||
constexpr auto enum_for_each_impl(Lambda&& lambda, std::index_sequence<Ix...>) {
|
||||
constexpr bool has_void_return = (std::is_void_v<std::invoke_result_t<Lambda, std::integral_constant<E, values_v<E>[Ix]>>> || ...);
|
||||
constexpr bool all_same_return = (std::is_same_v<
|
||||
std::invoke_result_t<Lambda, std::integral_constant<E, values_v<E>[0]>>,
|
||||
std::invoke_result_t<Lambda, std::integral_constant<E, values_v<E>[Ix]>>> && ...);
|
||||
|
||||
if constexpr (has_void_return) {
|
||||
(lambda(std::integral_constant<E, values_v<E>[Ix]>{}), ...);
|
||||
} else if constexpr (all_same_return) {
|
||||
return std::array{lambda(std::integral_constant<E, values_v<E>[Ix]>{}) ...};
|
||||
} else {
|
||||
return std::tuple{lambda(std::integral_constant<E, values_v<E>[Ix]>{}) ...};
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace magic_enum::detail
|
||||
|
||||
// Checks is magic_enum supported compiler.
|
||||
|
|
@ -1151,6 +1177,59 @@ template <typename E, typename BinaryPredicate = std::equal_to<char>>
|
|||
return static_cast<bool>(enum_cast<std::decay_t<E>>(value, std::move_if_noexcept(p)));
|
||||
}
|
||||
|
||||
template<typename ResultType = void, typename Lambda, typename E>
|
||||
constexpr auto enum_switch(Lambda&& lambda, E value) -> detail::enable_if_enum_t<E, ResultType> {
|
||||
return detail::constexpr_switch<&detail::values_v<std::decay_t<E>>, detail::case_call_t::value>(
|
||||
std::forward<Lambda>(lambda), value, detail::default_result_type_lambda<ResultType>);
|
||||
}
|
||||
|
||||
template<typename ResultType, typename Lambda, typename E>
|
||||
constexpr auto enum_switch(Lambda&& lambda, E value, ResultType&& result) -> detail::enable_if_enum_t<E, ResultType> {
|
||||
return detail::constexpr_switch<&detail::values_v<std::decay_t<E>>, detail::case_call_t::value>(
|
||||
std::forward<Lambda>(lambda), value,
|
||||
[&result] { return std::forward<ResultType>(result); });
|
||||
}
|
||||
|
||||
template<typename E, typename ResultType = void, typename BinaryPredicate = std::equal_to<char>, typename Lambda>
|
||||
constexpr auto enum_switch(Lambda&& lambda, std::string_view name, BinaryPredicate&& p = {})
|
||||
-> std::enable_if_t<std::is_enum_v<std::decay_t<E>> && std::is_invocable_r_v<bool, BinaryPredicate, char, char>, ResultType> {
|
||||
if (auto value = enum_cast<E>(name, std::forward<BinaryPredicate>(p))) {
|
||||
return enum_switch<ResultType>(std::forward<Lambda>(lambda), *value);
|
||||
}
|
||||
return detail::default_result_type_lambda<ResultType>();
|
||||
}
|
||||
|
||||
template<typename E, typename ResultType, typename BinaryPredicate = std::equal_to<char>, typename Lambda>
|
||||
constexpr auto enum_switch(Lambda&& lambda, std::string_view name, ResultType&& result, BinaryPredicate&& p = {})
|
||||
-> std::enable_if_t<std::is_enum_v<std::decay_t<E>> && std::is_invocable_r_v<bool, BinaryPredicate, char, char>, ResultType> {
|
||||
if (auto value = enum_cast<E>(name, std::forward<BinaryPredicate>(p))) {
|
||||
return enum_switch(std::forward<Lambda>(lambda), *value, std::forward<ResultType>(result));
|
||||
}
|
||||
return std::forward<ResultType>(result);
|
||||
}
|
||||
|
||||
template<typename E, typename ResultType = void, typename Lambda>
|
||||
constexpr auto enum_switch(Lambda&& lambda, underlying_type_t<std::decay_t<E>> raw_value) -> detail::enable_if_enum_t<E, ResultType> {
|
||||
if (auto value = enum_cast<E>(raw_value)) {
|
||||
return enum_switch<ResultType>(std::forward<Lambda>(lambda), *value);
|
||||
}
|
||||
return detail::default_result_type_lambda<ResultType>();
|
||||
}
|
||||
|
||||
template<typename E, typename ResultType, typename Lambda>
|
||||
constexpr auto enum_switch(Lambda&& lambda, underlying_type_t<std::decay_t<E>> raw_value, ResultType&& result) -> detail::enable_if_enum_t<E, ResultType> {
|
||||
if (auto value = enum_cast<E>(raw_value)) {
|
||||
return enum_switch(std::forward<Lambda>(lambda), *value, std::forward<ResultType>(result));
|
||||
}
|
||||
return std::forward<ResultType>(result);
|
||||
}
|
||||
|
||||
template<typename E, typename Lambda>
|
||||
constexpr auto enum_for_each(Lambda&& lambda)
|
||||
-> detail::enable_if_enum_t<E, decltype(detail::enum_for_each_impl<E>(std::declval<Lambda>(), std::make_index_sequence<detail::count_v<E>>{}))> {
|
||||
return detail::enum_for_each_impl<E>(std::forward<Lambda>(lambda), std::make_index_sequence<detail::count_v<E>>{});
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename E>
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue