enum_bitfield_t - operators ~, ^, ^= (#30)

* enum_bitfield_t - operators ~, ^, ^=

* bump version 0.9.2

---------

Co-authored-by: Artur Bać <[email protected]>

Author: arturbac

docs/enum_bitfiled.md

@@ -48,7 +48,7 @@ enum_bitfield_t support class template argument deducation when using arguments
 ```
 
 ```cpp
-  // operators |, &, |= &=
+  // operators |, &, |=, &=, ~, ^, ^=
   static_assert((enum_bitfield_t{v16, v21} | enum_bitfield_t{v31, v5}) 
                                         == enum_bitfield_t{v21, v16, v5, v31});
   static_assert((enum_bitfield_t{v16, v21, v34, v1} & enum_bitfield_t{v16, v21, v5})
@@ -61,5 +61,9 @@ enum_bitfield_t support class template argument deducation when using arguments
   enum_bitfield_t b{v16, v21};
   b |= enum_bitfield_t{v31, v5};
   expect(b == enum_bitfield_t{v21, v16, v5, v31});
+  
+  expect((enum_bitfield_t{v1, v2, v5, v6, v7} ^ enum_bitfield_t{v2, v5, v6}) == enum_bitfield_t{v1, v7});
+  
+  static_assert((~enum_bitfield_t{v1, v2, v5, v6, v7}) == enum_bitfield_t{v0, v3, v4, v8});
 ```
 

include/simple_enum/core.hpp

@@ -6,7 +6,7 @@
 #include <concepts>
 #include <type_traits>
 
-#define SIMPLE_ENUM_NAME_VERSION "0.9.1"
+#define SIMPLE_ENUM_NAME_VERSION "0.9.2"
 
 namespace simple_enum::inline v0_9
   {

include/simple_enum/enum_bitfield.h

@@ -70,16 +70,34 @@ namespace detail
       }
     };
 
+  /// \brief compile time bitmsk calculating
+  template<std::unsigned_integral T, std::size_t N>
+  struct bitmask_t
+    {
+    static T constexpr value = bitmask_t<T, (N - 1u)>::value | T(T(1u) << (N - 1));
+    };
+
+  template<std::unsigned_integral T>
+  struct bitmask_t<T, 0u>
+    {
+    static T constexpr value = T(0u);
+    };
+
+  template<std::unsigned_integral T, std::size_t N>
+  inline constexpr T bitmask_v = bitmask_t<T, N>::value;
   }  // namespace detail
 
 /// @brief A template struct providing a bitfield with enum indexing.
 template<enum_concept enum_type_t>
 struct enum_bitfield_t
   {
   using storage_t = detail::select_storage_for_enum_t<enum_type_t>;
+  static constexpr storage_t bits_mask{detail::bitmask_v<storage_t, enum_size_v<enum_type_t>>};
 
   storage_t bits_{0};
 
+  explicit operator storage_t() const noexcept { return bits_; }
+
   constexpr enum_bitfield_t() noexcept = default;
 
   explicit constexpr enum_bitfield_t(std::same_as<storage_t> auto bits) noexcept : bits_{bits} {}
@@ -114,6 +132,12 @@ struct enum_bitfield_t
   constexpr auto operator==(enum_bitfield_t const &) const noexcept -> bool
     = default;
 
+  [[nodiscard]]
+  constexpr auto operator~() const noexcept -> enum_bitfield_t
+    {
+    return enum_bitfield_t{storage_t((~bits_) & bits_mask)};
+    }
+
   [[nodiscard]]
   constexpr auto operator|(enum_bitfield_t const values) const noexcept -> enum_bitfield_t
     {
@@ -126,6 +150,12 @@ struct enum_bitfield_t
     return enum_bitfield_t{storage_t(bits_ & values.bits_)};
     }
 
+  [[nodiscard]]
+  constexpr auto operator^(enum_bitfield_t const values) const noexcept -> enum_bitfield_t
+    {
+    return enum_bitfield_t{storage_t((bits_ ^ values.bits_) & bits_mask)};
+    }
+
   constexpr auto operator|=(enum_bitfield_t const values) noexcept -> enum_bitfield_t &
     {
     bits_ |= values.bits_;
@@ -137,6 +167,12 @@ struct enum_bitfield_t
     bits_ &= values.bits_;
     return *this;
     }
+
+  constexpr auto operator^=(enum_bitfield_t const values) noexcept -> enum_bitfield_t &
+    {
+    bits_ = (bits_ ^ values.bits_) & bits_mask;
+    return *this;
+    }
   };
 
 template<enum_concept enum_type_t>

tests/enum_bitfield_ut.cc

@@ -17,7 +17,7 @@ enum struct color_t { red, green, blue, yellow, first = red, last = yellow };
 enum struct permission_t { read = 4, write = 8, execute = 16, first = read, last = execute };
 
 // Enum that should use uint16_t (9 values)
-enum struct medium_enum_t { v0, v1, v2, v3, v4, v5, v6, v7, v8, first = v0, last = v8 };
+enum struct medium_enum_t { v0 = 5, v1, v2, v3, v4, v5, v6, v7, v8, first = v0, last = v8 };
 
 // Enum that should use uint64_t (40 values)
 enum struct large_enum_t {
@@ -169,6 +169,61 @@ int main()
       }
     };
 
+    "operator ~"_test = []
+    {
+      {
+      using enum color_t;
+      expect((~enum_bitfield_t{red}) != enum_bitfield_t{red});
+      expect((~enum_bitfield_t{red, green}) == enum_bitfield_t{blue, yellow});
+      expect((~enum_bitfield_t{green}) == enum_bitfield_t{red, blue, yellow});
+      static_assert((~enum_bitfield_t{red, green}) == enum_bitfield_t{blue, yellow});
+      static_assert((~enum_bitfield_t{green}) == enum_bitfield_t{red, blue, yellow});
+      }
+      {
+      using enum medium_enum_t;
+      expect((~enum_bitfield_t{v1, v2, v5, v6, v7}) == enum_bitfield_t{v0, v3, v4, v8});
+      static_assert((~enum_bitfield_t{v1, v2, v5, v6, v7}) == enum_bitfield_t{v0, v3, v4, v8});
+      }
+    };
+
+    "operator ^"_test = []
+    {
+      using enum medium_enum_t;
+      expect((enum_bitfield_t{v1, v2, v5, v6, v7} ^ enum_bitfield_t{v2, v5, v6}) == enum_bitfield_t{v1, v7});
+      expect((enum_bitfield_t{v1, v2} ^ enum_bitfield_t{v5, v6}) == enum_bitfield_t{v1, v2, v5, v6});
+
+      static_assert((enum_bitfield_t{v1, v2, v5, v6, v7} ^ enum_bitfield_t{v2, v5, v6}) == enum_bitfield_t{v1, v7});
+      static_assert((enum_bitfield_t{v1, v2} ^ enum_bitfield_t{v5, v6}) == enum_bitfield_t{v1, v2, v5, v6});
+    };
+
+    "operator ^="_test = []
+    {
+      using enum medium_enum_t;
+      enum_bitfield_t a{v1, v2, v5, v6, v7};
+      a ^= enum_bitfield_t{v2, v5, v6};
+      expect(a == enum_bitfield_t{v1, v7});
+
+      enum_bitfield_t b{v1, v2};
+      b ^= enum_bitfield_t{v5, v6};
+      expect(b == enum_bitfield_t{v1, v2, v5, v6});
+
+      auto constexpr fn_a = []()
+      {
+        enum_bitfield_t x{v1, v2, v5, v6, v7};
+        x ^= enum_bitfield_t{v2, v5, v6};
+        return x;
+      };
+      static_assert(fn_a() == enum_bitfield_t{v1, v7});
+
+      auto constexpr fn_b = []()
+      {
+        enum_bitfield_t x{v1, v2};
+        x ^= enum_bitfield_t{v5, v6};
+        return x;
+      };
+      static_assert(fn_b() == enum_bitfield_t{v1, v2, v5, v6});
+    };
+
     "operator |"_test = []
     {
       using enum large_enum_t;