Add type traits

Add bitmask

Author: StormBytePP

README.md

@@ -778,6 +778,53 @@ int main() {
 }
 ```
 
+### Bitmask
+
+The `Bitmask` utility provides a type-safe, convenient way to work with flag enums. It uses a CRTP pattern so derived bitmask types preserve their concrete type when performing bitwise operations (so `a | b` returns the derived bitmask type, not the base class).
+
+Key points:
+
+- Uses `enum class` underlying values safely via `Type::ToUnderlying`.
+- Operators `|`, `&`, `^`, and `~` return the derived bitmask type (CRTP).
+- Provides helpers `Add`, `Remove`, `Has`, `Any`, `None`, and `Value()`.
+
+#### Example
+
+```cpp
+#include <StormByte/bitmask.hxx>
+#include <iostream>
+
+using namespace StormByte;
+
+enum class MyFlags : uint8_t {
+    FlagA = 0x01,
+    FlagB = 0x02,
+    FlagC = 0x04
+};
+
+class MyBitmask: public Bitmask<MyBitmask, MyFlags> {
+public:
+    using Bitmask<MyBitmask, MyFlags>::Bitmask;
+};
+
+int main() {
+    MyBitmask a(MyFlags::FlagA);
+    MyBitmask b(MyFlags::FlagB);
+
+    MyBitmask c = a | b; // returns MyBitmask
+
+    if (c.Value() == (MyFlags::FlagA | MyFlags::FlagB)) {
+        std::cout << "Flags A and B set\n";
+    }
+
+    c |= MyBitmask(MyFlags::FlagC);
+    c.Remove(MyFlags::FlagB);
+
+    std::cout << "Final value: " << static_cast<int>(Type::ToUnderlying(c.Value())) << std::endl;
+    return 0;
+}
+```
+
 ### Type Traits
 
 StormByte provides several custom type traits for compile-time type inspection, particularly useful for template metaprogramming and serialization.

lib/public/StormByte/type_traits.hxx

@@ -207,6 +207,21 @@ namespace StormByte {
 		template<typename E>
 		concept Enum = std::is_enum_v<std::remove_cv_t<E>>;
 
+		/**
+		 * @brief Concept to check if a type is an unsigned enumeration.
+		 * @tparam E Type to check.
+		 *
+		 * A type satisfies UnsignedEnum if it is an enumeration with an unsigned underlying type.
+		 * @code
+		 * template<Type::UnsignedEnum E>
+		 * void process(E value) { ... }
+		 * @endcode
+		 */
+		template<typename E>
+		concept UnsignedEnum =
+			Enum<E> &&
+			std::is_unsigned_v<std::underlying_type_t<std::remove_cv_t<E>>>;
+
 		/**
 		 * @brief Concept to check if a type is a scoped enumeration (enum class).
 		 * @tparam E Type to check.
@@ -220,6 +235,26 @@ namespace StormByte {
 		template<typename E>
 		concept ScopedEnum = std::is_scoped_enum_v<E>;
 
+		/**
+		 * @brief Alias type giving the underlying integer type of an enum `E`.
+		 *
+		 * Usage:
+		 * enum class Foo : uint16_t { A };
+		 * Type::underlying_type<Foo> value = 0;
+		 */
+		template<typename E>
+		requires Enum<E>
+		using UnderlyingType = std::underlying_type_t<std::remove_cv_t<E>>;
+
+		/**
+		 * @brief Convert an enum value to its underlying integer representation.
+		 */
+		template<typename E>
+		requires Enum<E>
+		constexpr UnderlyingType<E> ToUnderlying(E e) noexcept {
+			return static_cast<UnderlyingType<E>>(e);
+		}
+
 		/**
 		 * @brief Concept to check if a type is a pointer.
 		 * @tparam T Type to check.

test/CMakeLists.txt

@@ -2,6 +2,10 @@ option(ENABLE_TEST "Enable Unit Tests" OFF)
 if(ENABLE_TEST AND NOT STORMBYTE_AS_DEPENDENCY)
 	enable_testing()
 
+	add_executable(BitmaskTests bitmask_test.cxx)
+	target_link_libraries(BitmaskTests StormByte)
+	add_test(NAME BitmaskTests COMMAND BitmaskTests)
+
 	add_executable(IterableTests iterable_test.cxx)
 	target_link_libraries(IterableTests StormByte)
 	add_test(NAME IterableTests COMMAND IterableTests)