move all enum_flags_* func to enum_flags.hpp

doc/reference.md

@@ -422,6 +422,8 @@ template <typename E, typename BinaryPredicate>
 constexpr bool enum_flags_contains(string_view value, BinaryPredicate p) noexcept(is_nothrow_invocable_v<BinaryPredicate>);
 ```
 
+* You should add the required file `<magic_enum_flags.hpp>`.
+
 * Examples
 
   ```cpp
@@ -437,8 +439,15 @@ constexpr bool enum_flags_contains(string_view value, BinaryPredicate p) noexcep
   };
 
   magic_enum::enum_flags_name(Directions::Up | Directions::Right); // directions_name -> "Directions::Up|Directions::Right"
+
   magic_enum::enum_flags_contains(Directions::Up | Directions::Right); // -> true
+
   magic_enum::enum_flags_cast(3); // -> "Directions::Left|Directions::Down"
+
+  magic_enum::enum_flags_test(Left|Down, Down); // -> "true"
+  magic_enum::enum_flags_test(Left|Down, Right); // -> "false"
+
+  magic_enum::enum_flags_test_any(Left|Down|Right, Down|Right); // -> "true"
   ```
 
 ## `is_unscoped_enum`

include/magic_enum.hpp

@@ -1272,33 +1272,6 @@ template <detail::enum_subtype S, typename E>
   return enum_name<D, S>(value);
 }
 
-// Returns name from enum-flags value.
-// If enum-flags value does not have name or value out of range, returns empty string.
-template <typename E>
-[[nodiscard]] auto enum_flags_name(E value, char_type sep = static_cast<char_type>('|')) -> detail::enable_if_t<E, string> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-  constexpr auto S = detail::enum_subtype::flags;
-
-  string name;
-  auto check_value = U{0};
-  for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
-    if (const auto v = static_cast<U>(enum_value<D, S>(i)); (static_cast<U>(value) & v) != 0) {
-      check_value |= v;
-      const auto n = detail::names_v<D, S>[i];
-      if (!name.empty()) {
-        name.append(1, sep);
-      }
-      name.append(n.data(), n.size());
-    }
-  }
-
-  if (check_value != 0 && check_value == static_cast<U>(value)) {
-    return name;
-  }
-  return {}; // Invalid value or out of range.
-}
-
 // Returns std::array with names, sorted by enum value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
@@ -1347,41 +1320,6 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
   }
 }
 
-// Obtains enum-flags value from integer value.
-// Returns optional with enum-flags value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_flags_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-  constexpr auto S = detail::enum_subtype::flags;
-
-  if constexpr (detail::count_v<D, S> == 0) {
-    static_cast<void>(value);
-    return {}; // Empty enum.
-  } else {
-    if constexpr (detail::is_sparse_v<D, S>) {
-      auto check_value = U{0};
-      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
-        if (const auto v = static_cast<U>(enum_value<D, S>(i)); (value & v) != 0) {
-          check_value |= v;
-        }
-      }
-
-      if (check_value != 0 && check_value == value) {
-        return static_cast<D>(value);
-      }
-    } else {
-      constexpr auto min = detail::min_v<D, S>;
-      constexpr auto max = detail::values_ors<D, S>();
-
-      if (value >= min && value <= max) {
-        return static_cast<D>(value);
-      }
-    }
-    return {}; // Invalid value or out of range.
-  }
-}
-
 // Obtains enum value from name.
 // Returns optional with enum value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename BinaryPredicate = std::equal_to<>>
@@ -1413,43 +1351,6 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename Bi
   }
 }
 
-// Obtains enum-flags value from name.
-// Returns optional with enum-flags value.
-template <typename E, typename BinaryPredicate = std::equal_to<>>
-[[nodiscard]] constexpr auto enum_flags_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-  constexpr auto S = detail::enum_subtype::flags;
-
-  if constexpr (detail::count_v<D, S> == 0) {
-    static_cast<void>(value);
-    return {}; // Empty enum.
-  } else {
-    auto result = U{0};
-    while (!value.empty()) {
-      const auto d = detail::find(value, '|');
-      const auto s = (d == string_view::npos) ? value : value.substr(0, d);
-      auto f = U{0};
-      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
-        if (detail::cmp_equal(s, detail::names_v<D, S>[i], p)) {
-          f = static_cast<U>(enum_value<D, S>(i));
-          result |= f;
-          break;
-        }
-      }
-      if (f == U{0}) {
-        return {}; // Invalid value or out of range.
-      }
-      value.remove_prefix((d == string_view::npos) ? value.size() : d + 1);
-    }
-
-    if (result != U{0}) {
-      return static_cast<D>(result);
-    }
-    return {}; // Invalid value or out of range.
-  }
-}
-
 // Checks whether enum contains value with such value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t<E, bool> {
@@ -1468,15 +1369,6 @@ template <detail::enum_subtype S, typename E>
   return static_cast<bool>(enum_cast<D, S>(static_cast<U>(value)));
 }
 
-// Checks whether enum-flags contains value with such value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_flags_contains(E value) noexcept -> detail::enable_if_t<E, bool> {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  return static_cast<bool>(enum_flags_cast<D>(static_cast<U>(value)));
-}
-
 // Checks whether enum contains value with such integer value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
@@ -1485,14 +1377,6 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
   return static_cast<bool>(enum_cast<D, S>(value));
 }
 
-// Checks whether enum-flags contains value with such integer value.
-template <typename E>
-[[nodiscard]] constexpr auto enum_flags_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
-  using D = std::decay_t<E>;
-
-  return static_cast<bool>(enum_flags_cast<D>(value));
-}
-
 // Checks whether enum contains enumerator with such name.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename BinaryPredicate = std::equal_to<>>
 [[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, bool, BinaryPredicate> {
@@ -1501,14 +1385,6 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename Bi
   return static_cast<bool>(enum_cast<D, S>(value, std::move(p)));
 }
 
-// Checks whether enum-flags contains enumerator with such name.
-template <typename E, typename BinaryPredicate = std::equal_to<>>
-[[nodiscard]] constexpr auto enum_flags_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, bool, BinaryPredicate> {
-  using D = std::decay_t<E>;
-
-  return static_cast<bool>(enum_flags_cast<D>(value, std::move(p)));
-}
-
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename F, detail::enable_if_t<E, int> = 0>
 constexpr auto enum_for_each(F&& f) {
   using D = std::decay_t<E>;

include/magic_enum_flags.hpp

@@ -36,13 +36,137 @@
 
 namespace magic_enum {
 
+// Returns name from enum-flags value.
+// If enum-flags value does not have name or value out of range, returns empty string.
+template <typename E>
+[[nodiscard]] auto enum_flags_name(E value, char_type sep = static_cast<char_type>('|')) -> detail::enable_if_t<E, string> {
+  using D = std::decay_t<E>;
+  using U = underlying_type_t<D>;
+  constexpr auto S = detail::enum_subtype::flags;
+
+  string name;
+  auto check_value = U{0};
+  for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+    if (const auto v = static_cast<U>(enum_value<D, S>(i)); (static_cast<U>(value) & v) != 0) {
+      check_value |= v;
+      const auto n = detail::names_v<D, S>[i];
+      if (!name.empty()) {
+        name.append(1, sep);
+      }
+      name.append(n.data(), n.size());
+    }
+  }
+
+  if (check_value != 0 && check_value == static_cast<U>(value)) {
+    return name;
+  }
+  return {}; // Invalid value or out of range.
+}
+
+// Obtains enum-flags value from integer value.
+// Returns optional with enum-flags value.
+template <typename E>
+[[nodiscard]] constexpr auto enum_flags_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
+  using D = std::decay_t<E>;
+  using U = underlying_type_t<D>;
+  constexpr auto S = detail::enum_subtype::flags;
+
+  if constexpr (detail::count_v<D, S> == 0) {
+    static_cast<void>(value);
+    return {}; // Empty enum.
+  } else {
+    if constexpr (detail::is_sparse_v<D, S>) {
+      auto check_value = U{0};
+      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+        if (const auto v = static_cast<U>(enum_value<D, S>(i)); (value & v) != 0) {
+          check_value |= v;
+        }
+      }
+
+      if (check_value != 0 && check_value == value) {
+        return static_cast<D>(value);
+      }
+    } else {
+      constexpr auto min = detail::min_v<D, S>;
+      constexpr auto max = detail::values_ors<D, S>();
+
+      if (value >= min && value <= max) {
+        return static_cast<D>(value);
+      }
+    }
+    return {}; // Invalid value or out of range.
+  }
+}
+
+// Obtains enum-flags value from name.
+// Returns optional with enum-flags value.
+template <typename E, typename BinaryPredicate = std::equal_to<>>
+[[nodiscard]] constexpr auto enum_flags_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
+  using D = std::decay_t<E>;
+  using U = underlying_type_t<D>;
+  constexpr auto S = detail::enum_subtype::flags;
+
+  if constexpr (detail::count_v<D, S> == 0) {
+    static_cast<void>(value);
+    return {}; // Empty enum.
+  } else {
+    auto result = U{0};
+    while (!value.empty()) {
+      const auto d = detail::find(value, '|');
+      const auto s = (d == string_view::npos) ? value : value.substr(0, d);
+      auto f = U{0};
+      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+        if (detail::cmp_equal(s, detail::names_v<D, S>[i], p)) {
+          f = static_cast<U>(enum_value<D, S>(i));
+          result |= f;
+          break;
+        }
+      }
+      if (f == U{0}) {
+        return {}; // Invalid value or out of range.
+      }
+      value.remove_prefix((d == string_view::npos) ? value.size() : d + 1);
+    }
+
+    if (result != U{0}) {
+      return static_cast<D>(result);
+    }
+    return {}; // Invalid value or out of range.
+  }
+}
+
+// Checks whether enum-flags contains value with such value.
+template <typename E>
+[[nodiscard]] constexpr auto enum_flags_contains(E value) noexcept -> detail::enable_if_t<E, bool> {
+  using D = std::decay_t<E>;
+  using U = underlying_type_t<D>;
+
+  return static_cast<bool>(enum_flags_cast<D>(static_cast<U>(value)));
+}
+
+// Checks whether enum-flags contains value with such integer value.
+template <typename E>
+[[nodiscard]] constexpr auto enum_flags_contains(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, bool> {
+  using D = std::decay_t<E>;
+
+  return static_cast<bool>(enum_flags_cast<D>(value));
+}
+
+// Checks whether enum-flags contains enumerator with such name.
+template <typename E, typename BinaryPredicate = std::equal_to<>>
+[[nodiscard]] constexpr auto enum_flags_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, bool, BinaryPredicate> {
+  using D = std::decay_t<E>;
+
+  return static_cast<bool>(enum_flags_cast<D>(value, std::move(p)));
+}
+
 // Checks whether `flags set` contains `flag`.
 // Note: If `flag` equals 0, it returns false, as 0 is not a flag.
 template <typename E>
 constexpr auto enum_flags_test(E flags, E flag) noexcept -> detail::enable_if_t<E, bool> {
   using U = underlying_type_t<E>;
 
-  return static_cast<bool>(static_cast<U>(flags) & static_cast<U>(flag));
+  return static_cast<U>(flag) && ((static_cast<U>(flags) & static_cast<U>(flag)) == static_cast<U>(flag));
 }
 
 // Checks whether `lhs flags set` and `rhs flags set` have common flags.

include/magic_enum_format.hpp

@@ -33,6 +33,7 @@
 #define NEARGYE_MAGIC_ENUM_FORMAT_HPP
 
 #include "magic_enum.hpp"
+#include "magic_enum_flags.hpp"
 
 #if !defined(MAGIC_ENUM_DEFAULT_ENABLE_ENUM_FORMAT)
 #  define MAGIC_ENUM_DEFAULT_ENABLE_ENUM_FORMAT 1

include/magic_enum_iostream.hpp

@@ -33,6 +33,8 @@
 #define NEARGYE_MAGIC_ENUM_IOSTREAM_HPP
 
 #include "magic_enum.hpp"
+#include "magic_enum_flags.hpp"
+
 #include <iosfwd>
 
 namespace magic_enum {

test/test_aliases.cpp

@@ -97,6 +97,7 @@ constexpr bool operator==(MyStringView lhs, MyStringView rhs) {
 #define MAGIC_ENUM_USING_ALIAS_STRING_VIEW using string_view = MyStringView;
 
 #include <magic_enum.hpp>
+#include <magic_enum_flags.hpp>
 using namespace magic_enum;
 using namespace magic_enum::bitwise_operators;
 

test/test_flags.cpp

@@ -761,6 +761,7 @@ TEST_CASE("enum_flags_test_any") {
   REQUIRE_FALSE(enum_flags_test_any(Left|Up|Down, Right));
 
   REQUIRE(enum_flags_test_any(number::one|number::two|number::four, number::one));
+  REQUIRE(enum_flags_test_any(number::one|number::two|number::four, number::one|number::two));
   REQUIRE_FALSE(enum_flags_test_any(number::one|number::two|number::four, number::three));
   REQUIRE_FALSE(enum_flags_test_any(number::one|number::two|number::four, number::no_number));