🎨 Use enums with bit_mask

Problem:
- It's useful to compute a `bit_mask` and give it an enumeration type.

Solution:
- Allow `bit_mask` to return values that are enumeration type.

Author: elbeno

include/stdx/bit.hpp

@@ -399,21 +399,24 @@ template <typename T, std::size_t N> struct bitmask_subtract<std::array<T, N>> {
 };
 } // namespace detail
 
-template <typename T, std::size_t Msb = detail::num_digits_v<T> - 1,
+template <typename T,
+          std::size_t Msb = detail::num_digits_v<underlying_type_t<T>> - 1,
           std::size_t Lsb = 0>
 [[nodiscard]] CONSTEVAL auto bit_mask() noexcept -> T {
-    static_assert(Msb < detail::num_digits_v<T>,
+    using U = underlying_type_t<T>;
+    static_assert(Msb < detail::num_digits_v<U>,
                   "bit_mask requested exceeds the range of the type");
     static_assert(Msb >= Lsb, "bit_mask range is invalid");
-    return detail::bitmask_subtract<T>{}(detail::mask_bits_t<T>{}(Msb + 1),
-                                         detail::mask_bits_t<T>{}(Lsb));
+    return static_cast<T>(detail::bitmask_subtract<U>{}(
+        detail::mask_bits_t<U>{}(Msb + 1), detail::mask_bits_t<U>{}(Lsb)));
 }
 
 template <typename T>
 [[nodiscard]] constexpr auto bit_mask(std::size_t Msb,
                                       std::size_t Lsb = 0) noexcept -> T {
-    return detail::bitmask_subtract<T>{}(detail::mask_bits_t<T>{}(Msb + 1),
-                                         detail::mask_bits_t<T>{}(Lsb));
+    using U = underlying_type_t<T>;
+    return static_cast<T>(detail::bitmask_subtract<U>{}(
+        detail::mask_bits_t<U>{}(Msb + 1), detail::mask_bits_t<U>{}(Lsb)));
 }
 
 template <typename T> constexpr auto bit_size() -> std::size_t {

test/bit.cpp

@@ -256,44 +256,53 @@ TEST_CASE("template bit_mask (single bit)", "[bit]") {
 TEST_CASE("template bit_mask (array type whole range)", "[bit]") {
     using A = std::array<std::uint8_t, 3>;
     constexpr auto m = stdx::bit_mask<A>();
-    CHECK(m == A{0xff, 0xff, 0xff});
+    STATIC_REQUIRE(m == A{0xff, 0xff, 0xff});
 }
 
 TEST_CASE("template bit_mask (array type low bits)", "[bit]") {
     using A = std::array<std::uint8_t, 3>;
     constexpr auto m = stdx::bit_mask<A, 1, 0>();
-    CHECK(m == A{0b0000'0011, 0, 0});
+    STATIC_REQUIRE(m == A{0b0000'0011, 0, 0});
 }
 
 TEST_CASE("template bit_mask (array type mid bits)", "[bit]") {
     using A = std::array<std::uint8_t, 3>;
     constexpr auto m = stdx::bit_mask<A, 19, 4>();
-    CHECK(m == A{0b1111'0000, 0xff, 0b0000'1111});
+    STATIC_REQUIRE(m == A{0b1111'0000, 0xff, 0b0000'1111});
 }
 
 TEST_CASE("template bit_mask (array type high bits)", "[bit]") {
     using A = std::array<std::uint8_t, 3>;
     constexpr auto m = stdx::bit_mask<A, 23, 20>();
-    CHECK(m == A{0, 0, 0b1111'0000});
+    STATIC_REQUIRE(m == A{0, 0, 0b1111'0000});
 }
 
 TEST_CASE("template bit_mask (array type single bit)", "[bit]") {
     using A = std::array<std::uint8_t, 3>;
     constexpr auto m = stdx::bit_mask<A, 5, 5>();
-    CHECK(m == A{0b0010'0000, 0, 0});
+    STATIC_REQUIRE(m == A{0b0010'0000, 0, 0});
 }
 
 TEST_CASE("template bit_mask (array of array type)", "[bit]") {
     using A = std::array<std::uint8_t, 1>;
     using B = std::array<A, 3>;
     constexpr auto m = stdx::bit_mask<B, 19, 4>();
-    CHECK(m == B{A{0b1111'0000}, A{0xff}, A{0b0000'1111}});
+    STATIC_REQUIRE(m == B{A{0b1111'0000}, A{0xff}, A{0b0000'1111}});
 }
 
 TEST_CASE("template bit_mask (large array type)", "[bit]") {
     using A = std::array<std::uint64_t, 4>;
     constexpr auto m = stdx::bit_mask<A, 192, 192>();
-    CHECK(m == A{0, 0, 0, 1});
+    STATIC_REQUIRE(m == A{0, 0, 0, 1});
+}
+
+namespace {
+enum struct scoped_enum : std::uint8_t { A, B, C };
+} // namespace
+
+TEST_CASE("template bit_mask (enum type)", "[bit]") {
+    constexpr auto m = stdx::bit_mask<scoped_enum>();
+    STATIC_REQUIRE(m == scoped_enum{0xffu});
 }
 
 TEST_CASE("arg bit_mask (whole range)", "[bit]") {
@@ -326,6 +335,11 @@ TEST_CASE("arg bit_mask (single bit)", "[bit]") {
     STATIC_REQUIRE(std::is_same_v<decltype(m), std::uint8_t const>);
 }
 
+TEST_CASE("arg bit_mask (enum type)", "[bit]") {
+    constexpr auto m = stdx::bit_mask<scoped_enum>(1);
+    STATIC_REQUIRE(m == scoped_enum{0b11u});
+}
+
 TEMPLATE_TEST_CASE("bit_size", "[bit]", std::uint8_t, std::uint16_t,
                    std::uint32_t, std::uint64_t, std::int8_t, std::int16_t,
                    std::int32_t, std::int64_t) {