mirror/magic_enum
1
0
Fork 0
mirror of https://github.com/Neargye/magic_enum.git synced 2026-01-09 23:34:23 +00:00
Code Activity

wip

Browse source
This commit is contained in:
neargye 2020-08-15 22:47:20 +05:00
parent 7892516990
commit d525acae66
3 changed files with 131 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

22
example/enum_flag_example.cpp
View file

@ -34,21 +34,17 @@ int main() {
std::cout << f1_name << std::endl; // Endangered
// String enum name sequence.
constexpr auto names = magic_enum::flags::enum_names<AnimalFlags>();
constexpr auto& names = magic_enum::flags::enum_names<AnimalFlags>();
std::cout << "AnimalFlags names:";
for (auto n : names) {
for (const auto& n : names) {
std::cout << " " << n;
}
std::cout << std::endl;
// AnimalFlags names: HasClaws CanFly EatsFish Endangered
#if 0
// String name to enum value.
auto f2 = magic_enum::flags::enum_cast<AnimalFlags>("EatsFish|CanFly");
#else
auto f2 = magic_enum::flags::enum_cast<AnimalFlags>(1074790400);
#endif
if (f2.has_value() && f2.value() == AnimalFlags::EatsFish) {
if (f2.has_value()) {
std::cout << "EatsFish = " << magic_enum::flags::enum_integer(f2.value()) << std::endl; // CanFly|EatsFish = 1074790400
}
@ -60,9 +56,7 @@ auto f2 = magic_enum::flags::enum_cast<AnimalFlags>(1074790400);
// Enum value to integer value.
auto f4_integer = magic_enum::flags::enum_integer(AnimalFlags::HasClaws);
if (f4_integer == static_cast<std::underlying_type_t<AnimalFlags>>(AnimalFlags::HasClaws)) {
std::cout << "HasClaws = " << f4_integer << std::endl; // HasClaws = 1024
}
std::cout << "HasClaws = " << f4_integer << std::endl; // HasClaws = 1024
using namespace magic_enum::flags::ostream_operators; // out-of-the-box ostream operator for all enums.
// ostream operator for enum.
@ -75,9 +69,9 @@ auto f2 = magic_enum::flags::enum_cast<AnimalFlags>(1074790400);
std::cout << "AnimalFlags[0] = " << magic_enum::flags::enum_value<AnimalFlags>(0) << std::endl; // AnimalFlags[0] = HasClaws
// Enum value sequence.
constexpr auto values = magic_enum::flags::enum_values<AnimalFlags>();
constexpr auto& values = magic_enum::flags::enum_values<AnimalFlags>();
std::cout << "AnimalFlags values:";
for (AnimalFlags f : values) {
for (const auto& f : values) {
std::cout << " " << f; // ostream operator for enum.
}
std::cout << std::endl;
@ -89,9 +83,9 @@ auto f2 = magic_enum::flags::enum_cast<AnimalFlags>(1074790400);
std::cout << flag << std::endl; // HasClaws|CanFly
// Enum pair (value enum, string enum name) sequence.
constexpr auto entries = magic_enum::flags::enum_entries<AnimalFlags>();
constexpr auto& entries = magic_enum::flags::enum_entries<AnimalFlags>();
std::cout << "AnimalFlags entries:";
for (auto e : entries) {
for (const auto& e : entries) {
std::cout << " " << e.second << " = " << magic_enum::flags::enum_integer(e.first);
}
std::cout << std::endl;

20
example/example.cpp
View file

@ -39,9 +39,9 @@ int main() {
std::cout << c1_name << std::endl; // RED
// String enum name sequence.
constexpr auto names = magic_enum::enum_names<Color>();
constexpr auto& names = magic_enum::enum_names<Color>();
std::cout << "Color names:";
for (auto n : names) {
for (const auto& n : names) {
std::cout << " " << n;
}
std::cout << std::endl;
@ -49,21 +49,19 @@ int main() {
// String name to enum value.
auto c2 = magic_enum::enum_cast<Color>("BLUE");
if (c2.has_value() && c2.value() == Color::BLUE) {
if (c2.has_value()) {
std::cout << "BLUE = " << to_integer(c2.value()) << std::endl; // BLUE = 0
}
// Integer value to enum value.
auto c3 = magic_enum::enum_cast<Color>(10);
if (c3.has_value() && c3.value() == Color::GREEN) {
if (c3.has_value()) {
std::cout << "GREEN = " << magic_enum::enum_integer(c3.value()) << std::endl; // GREEN = 10
}
// Enum value to integer value.
auto c4_integer = magic_enum::enum_integer(Color::RED);
if (c4_integer == static_cast<std::underlying_type_t<Color>>(Color::RED)) {
std::cout << "RED = " << c4_integer << std::endl; // RED = -10
}
std::cout << "RED = " << c4_integer << std::endl; // RED = -10
using namespace magic_enum::ostream_operators; // out-of-the-box ostream operator for all enums.
// ostream operator for enum.
@ -76,9 +74,9 @@ int main() {
std::cout << "Color[0] = " << magic_enum::enum_value<Color>(0) << std::endl; // Color[0] = RED
// Enum value sequence.
constexpr auto values = magic_enum::enum_values<Color>();
constexpr auto& values = magic_enum::enum_values<Color>();
std::cout << "Colors values:";
for (Color c : values) {
for (const auto& c : values) {
std::cout << " " << c; // ostream operator for enum.
}
std::cout << std::endl;
@ -103,9 +101,9 @@ int main() {
static_assert(magic_enum::is_scoped_enum_v<Flags>);
// Enum pair (value enum, string enum name) sequence.
constexpr auto entries = magic_enum::enum_entries<Color>();
constexpr auto& entries = magic_enum::enum_entries<Color>();
std::cout << "Colors entries:";
for (auto e : entries) {
for (const auto& e : entries) {
std::cout << " " << e.second << " = " << static_cast<int>(e.first);
}
std::cout << std::endl;

239
include/magic_enum.hpp
View file

@ -665,6 +665,19 @@ template <typename E>
return detail::entries_v<D>;
}
// Obtains enum value from integer value.
// Returns std::optional with enum value.
template <typename E>
[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, std::optional<std::decay_t<E>>> {
using D = std::decay_t<E>;
if (detail::undex<D>(value) != detail::invalid_index_v<D>) {
return static_cast<D>(value);
}
return std::nullopt; // Invalid value or out of range.
}
// Obtains enum value from string name.
// Returns std::optional with enum value.
template <typename E, typename BinaryPredicate>
@ -690,19 +703,6 @@ template <typename E>
return enum_cast<D>(value, detail::char_equal_to{});
}
// Obtains enum value from integer value.
// Returns std::optional with enum value.
template <typename E>
[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_t<E, std::optional<std::decay_t<E>>> {
using D = std::decay_t<E>;
if (detail::undex<D>(value) != detail::invalid_index_v<D>) {
return static_cast<D>(value);
}
return std::nullopt; // Invalid value or out of range.
}
// Returns integer value from enum value.
template <typename E>
[[nodiscard]] constexpr underlying_type_t<E> enum_integer(E value) noexcept {
@ -744,7 +744,7 @@ template <typename E, typename BinaryPredicate>
using D = std::decay_t<E>;
static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::enum_contains requires bool(char, char) invocable predicate.");
return enum_cast<D>(value, std::move(p)).has_value();
return enum_cast<D>(value, std::move_if_noexcept(p)).has_value();
}
// Checks whether enum contains enumerator with such string name.
@ -826,6 +826,9 @@ constexpr E& operator^=(E& lhs, E rhs) noexcept {
namespace flags {
// Returns string name of enum type.
using magic_enum::enum_type_name;
// Returns number of enum-flags values.
template <typename E>
[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_enum_flags_t<E, std::size_t> {
@ -908,100 +911,91 @@ template <typename E>
return detail::entries_v<D, true>;
}
// Checks whether enum-flags contains enumerator with such integer value.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
if constexpr(Strict) {
if constexpr (detail::is_sparse_v<D, true>) {
for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
if (value == enum_value<D>(i)) {
return true;
}
}
return false;
}
} else {
if constexpr (detail::is_sparse_v<D, true>) {
using U = underlying_type_t<D>;
auto check_value = U{0};
for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
if (const auto v = static_cast<U>(enum_value<D>(i)); (static_cast<U>(value) & v) != 0) {
check_value |= v;
}
}
return check_value == value;
} else {
constexpr auto min = detail::min_v<D, true>;
constexpr auto max = detail::value_ors<D>();
return value >= min && value <= max;
}
}
}
// Checks whether enum-flags contains enumerator with such enum-flags value.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
using U = underlying_type_t<D>;
return enum_contains<D, Strict>(static_cast<U>(value));
}
// Checks whether enum-flags contains enumerator with such string name.
template <typename E, typename BinaryPredicate>
[[nodiscard]] constexpr auto enum_contains(std::string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::flags::enum_contains requires bool(char, char) invocable predicate.");
// TODO: impl
static_assert(sizeof(decltype(value)) == sizeof(E) * 0, "not implemented");
return {};
}
// Checks whether enum-flags contains enumerator with such string name.
template <typename E>
[[nodiscard]] constexpr auto enum_contains(std::string_view value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
// TODO: impl
static_assert(sizeof(decltype(value)) == sizeof(E) * 0, "not implemented");
return {};
}
// Obtains enum-flags value from integer value.
// Returns std::optional with enum-flags value.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_flags_t<E, std::optional<std::decay_t<E>>> {
using D = std::decay_t<E>;
using U = underlying_type_t<D>;
if (enum_contains<D, Strict>(value)) {
return static_cast<D>(value);
if constexpr(Strict) {
for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
if (value == static_cast<U>(enum_value<D>(i))) {
return static_cast<D>(value);
}
}
} else {
if constexpr (detail::is_sparse_v<D, true>) {
auto check_value = U{0};
for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
if (const auto v = static_cast<U>(enum_value<D>(i)); (value & v) != 0) {
check_value |= v;
}
}
if (check_value == value) {
return static_cast<D>(value);
}
} else {
constexpr auto min = detail::min_v<D, true>;
constexpr auto max = detail::value_ors<D>();
if (value >= min && value <= max) {
return static_cast<D>(value);
}
}
}
return std::nullopt; // Invalid value or out of range.
return std::nullopt;
}
// Obtains enum-flags value from string name.
// Returns std::optional with enum-flags value.
template <typename E, typename BinaryPredicate>
template <typename E, bool Strict = false, typename BinaryPredicate>
[[nodiscard]] constexpr auto enum_cast(std::string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_flags_t<E, std::optional<std::decay_t<E>>> {
static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::flags::enum_cast requires bool(char, char) invocable predicate.");
// TODO: impl
static_assert(sizeof(decltype(value)) + sizeof(decltype(p)) == sizeof(E) * 0, "not implemented");
return {};
using D = std::decay_t<E>;
using U = underlying_type_t<D>;
auto result = U{0};
while (!value.empty()) {
const auto d = value.find_first_of('|');
const auto s = (d == std::string_view::npos) ? value : value.substr(0, d);
auto f = U{0};
for (std::size_t i = 0; i < detail::count_v<D, true>; ++i) {
if (detail::cmp_equal(s, detail::names_v<D, true>[i], p)) {
f = static_cast<U>(enum_value<D>(i));
result |= f;
break;
}
}
if (f == 0) {
return std::nullopt;
} else {
result |= f;
}
value.remove_prefix((d == std::string_view::npos) ? value.size() : d + 1);
}
if (result == 0) {
return std::nullopt;
} else {
return static_cast<D>(result);
}
}
// Obtains enum-flags value from string name.
// Returns std::optional with enum-flags value.
template <typename E>
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_cast(std::string_view value) noexcept -> detail::enable_if_enum_flags_t<E, std::optional<std::decay_t<E>>> {
// TODO: impl
static_assert(sizeof(decltype(value)) == sizeof(E) * 0, "not implemented");
return {};
using D = std::decay_t<E>;
return enum_cast<D, Strict>(value, detail::char_equal_to{});
}
// Returns integer value from enum value.
using magic_enum::enum_integer;
// Obtains index in enum-flags values from enum-flags value.
// Returns std::optional with index.
template <typename E>
@ -1019,11 +1013,39 @@ template <typename E>
return std::nullopt; // Value out of range.
}
// Returns string name of enum type.
using magic_enum::enum_type_name;
// Checks whether enum-flags contains enumerator with such enum-flags value.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
using U = underlying_type_t<D>;
// Returns integer value from enum value.
using magic_enum::enum_integer;
return enum_cast<D, Strict>(static_cast<U>(value));
}
// Checks whether enum-flags contains enumerator with such integer value.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
return enum_cast<D, Strict>(value).has_value();
}
// Checks whether enum-flags contains enumerator with such string name.
template <typename E, bool Strict = false, typename BinaryPredicate>
[[nodiscard]] constexpr auto enum_contains(std::string_view value, BinaryPredicate p) noexcept(std::is_nothrow_invocable_r_v<bool, BinaryPredicate, char, char>) -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
static_assert(std::is_invocable_r_v<bool, BinaryPredicate, char, char>, "magic_enum::flags::enum_contains requires bool(char, char) invocable predicate.");
return enum_cast<D, Strict>(value, std::move_if_noexcept(p)).has_value();
}
// Checks whether enum-flags contains enumerator with such string name.
template <typename E, bool Strict = false>
[[nodiscard]] constexpr auto enum_contains(std::string_view value) noexcept -> detail::enable_if_enum_flags_t<E, bool> {
using D = std::decay_t<E>;
return enum_cast<D, Strict>(value).has_value();
}
namespace ostream_operators {
@ -1056,40 +1078,7 @@ std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& o
namespace bitwise_operators {
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E operator~(E rhs) noexcept {
return static_cast<E>(~static_cast<underlying_type_t<E>>(rhs));
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E operator|(E lhs, E rhs) noexcept {
return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) | static_cast<underlying_type_t<E>>(rhs));
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E operator&(E lhs, E rhs) noexcept {
return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) & static_cast<underlying_type_t<E>>(rhs));
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E operator^(E lhs, E rhs) noexcept {
return static_cast<E>(static_cast<underlying_type_t<E>>(lhs) ^ static_cast<underlying_type_t<E>>(rhs));
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E& operator|=(E& lhs, E rhs) noexcept {
return lhs = lhs | rhs;
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E& operator&=(E& lhs, E rhs) noexcept {
return lhs = lhs & rhs;
}
template <typename E, detail::enable_if_enum_flags_t<E, int> = 0>
constexpr E& operator^=(E& lhs, E rhs) noexcept {
return lhs = lhs ^ rhs;
}
using namespace magic_enum::bitwise_operators;
} // namespace magic_enum::flags::bitwise_operators