add bitwise_operators

README.md

@@ -118,7 +118,7 @@ enum Color { RED = 2, BLUE = 4, GREEN = 8 };
 
 * Stream operator for enum
   ```cpp
-  using namespace magic_enum::ops; // out-of-the-box stream operator for enums.
+  using namespace magic_enum::ostream_operators; // out-of-the-box ostream operators for enums.
   Color color = Color::BLUE;
   std::cout << color << std::endl; // "BLUE"
   ```

example/example.cpp

@@ -59,7 +59,7 @@ int main() {
     std::cout << "RED = " << color_integer << std::endl; // RED = -10
   }
 
-  using namespace magic_enum::ops; // out-of-the-box stream operator for enums.
+  using namespace magic_enum::ostream_operators; // out-of-the-box ostream operator for enums.
   // ostream operator for enum.
   std::cout << "Color: " << c1 << " " << c2 << " " << c3 << std::endl; // Color: RED BLUE GREEN
 

include/magic_enum.hpp

@@ -368,11 +368,11 @@ template <typename E, typename D = detail::enable_if_enum_t<E>>
   return entries;
 }
 
-namespace ops {
+namespace ostream_operators {
 
 template <class Char, class Traits, typename E, typename D = detail::enable_if_enum_t<E>>
 std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, E value) {
-  static_assert(detail::check_enum_v<E, D>, "magic_enum::ops::operator<< requires enum type.");
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::ostream_operators::operator<< requires enum type.");
 
   if (auto name = detail::name_impl<D>(static_cast<int>(value)); !name.empty()) {
     for (auto c : name) {
@@ -385,7 +385,7 @@ std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& o
 
 template <class Char, class Traits, typename E, typename D = detail::enable_if_enum_t<E>>
 std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, std::optional<E> value) {
-  static_assert(detail::check_enum_v<E, D>, "magic_enum::ops::operator<< requires enum type.");
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::ostream_operators::operator<< requires enum type.");
 
   if (value.has_value()) {
     if (auto name = detail::name_impl<D>(static_cast<int>(value.value())); !name.empty()) {
@@ -398,7 +398,67 @@ std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& o
   return os;
 }
 
-} // namespace magic_enum::ops
+} // namespace magic_enum::ostream_operators
+
+namespace bitwise_operators {
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E operator~(E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator~ requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return static_cast<E>(~static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E operator|(E lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator| requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return static_cast<E>(static_cast<U>(lhs) | static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E operator&(E lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator& requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return static_cast<E>(static_cast<U>(lhs) & static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E operator^(E lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator^ requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return static_cast<E>(static_cast<U>(lhs) ^ static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E& operator|=(E& lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator|= requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return lhs = static_cast<E>(static_cast<U>(lhs) | static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E& operator&=(E& lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator%= requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return lhs = static_cast<E>(static_cast<U>(lhs) & static_cast<U>(rhs));
+}
+
+template <typename E, typename D = detail::enable_if_enum_t<E>>
+constexpr E& operator^=(E& lhs, E rhs) {
+  static_assert(detail::check_enum_v<E, D>, "magic_enum::bitwise_operators::operator^= requires enum type.");
+  using U = std::underlying_type_t<D>;
+
+  return lhs = static_cast<E>(static_cast<U>(lhs) ^ static_cast<U>(rhs));
+}
+
+} // namespace magic_enum::bitwise_operators
 
 } // namespace magic_enum
 

test/test.cpp

@@ -291,9 +291,9 @@ TEST_CASE("enum_entries") {
   REQUIRE(s4 == std::array<std::pair<number, std::string_view>, 3>{{{number::one, "one"}, {number::two, "two"}, {number::three, "three"}}});
 }
 
-TEST_CASE("operator<<") {
+TEST_CASE("ostream_operators") {
   auto test_ostream = [](auto e, std::string_view name) {
-    using namespace magic_enum::ops;
+    using namespace magic_enum::ostream_operators;
     std::stringstream ss;
     ss << e;
     REQUIRE(ss.str() == name);
@@ -323,6 +323,9 @@ TEST_CASE("operator<<") {
   test_ostream(static_cast<number>(0), "");
 }
 
+TEST_CASE("bitwise_operators") {
+}
+
 TEST_CASE("type_traits") {
   REQUIRE_FALSE(magic_enum::is_unscoped_enum_v<Color>);
   REQUIRE_FALSE(magic_enum::is_unscoped_enum_v<Numbers>);