wip

example/enum_flag_example.cpp

@@ -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
+  if (f2.has_value()) {
-auto f2 = magic_enum::flags::enum_cast<AnimalFlags>(1074790400);
-#endif
-  if (f2.has_value() && f2.value() == AnimalFlags::EatsFish) {
     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
-  }
 
   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;

example/example.cpp

@@ -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
-  }
 
   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;

include/magic_enum.hpp

@@ -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)) {
+  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;
+        }
+      }
 
-  return std::nullopt; // Invalid value or out of range.
+      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;
 }
 
 // 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
+  using D = std::decay_t<E>;
-  static_assert(sizeof(decltype(value)) + sizeof(decltype(p)) == sizeof(E) * 0, "not implemented");
+  using U = underlying_type_t<D>;
-  return {};
+
+  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
+  using D = std::decay_t<E>;
-  static_assert(sizeof(decltype(value)) == sizeof(E) * 0, "not implemented");
+
-  return {};
+  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.
+// Checks whether enum-flags contains enumerator with such enum-flags value.
-using magic_enum::enum_type_name;
+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.
+  return enum_cast<D, Strict>(static_cast<U>(value));
-using magic_enum::enum_integer;
+}
+
+// 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>
+using namespace magic_enum::bitwise_operators;
-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;
-}
 
 } // namespace magic_enum::flags::bitwise_operators