Replace utils_enum helpers with std::to_underlying

Remove the custom `utils_enum.h` header (which provided `common::ToValue` and `common::FromValue`) and replace all usages with C++23's `std::to_underlying` and `static_cast` respectively. Update `utils_flags.h` to use `std::to_underlying` directly. Also includes minor code style cleanups (whitespace, brace style) across affected files.

Author: vanvught

common/include/common/utils/utils_enum.h

@@ -1,8 +1,8 @@
 /**
  * @file utils_flags.h
- * Generic enum class bitmask helpers (C++20, freestanding-safe, Google Style)
+ * Generic enum class bitmask helpers (C++23, freestanding-safe, Google Style)
  */
-/* Copyright (C) 2025 by Arjan van Vught mailto:info@gd32-dmx.org
+/* Copyright (C) 2025-2026 by Arjan van Vught mailto:info@gd32-dmx.org
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -28,26 +28,25 @@
 
 #include <cstdint>
 #include <type_traits>
-
-#include "common/utils/utils_enum.h" // Ensure this provides ToValue and FromValue
+#include <utility>
 
 namespace common {
 template <typename E>
     requires std::is_enum_v<E>
 constexpr E operator|(E lhs, E rhs) {
-    return static_cast<E>(ToValue(lhs) | ToValue(rhs));
+    return static_cast<E>(std::to_underlying(lhs) | std::to_underlying(rhs));
 }
 
 template <typename E>
     requires std::is_enum_v<E>
 constexpr E operator&(E lhs, E rhs) {
-    return static_cast<E>(ToValue(lhs) & ToValue(rhs));
+    return static_cast<E>(std::to_underlying(lhs) & std::to_underlying(rhs));
 }
 
 template <typename E>
     requires std::is_enum_v<E>
 constexpr E operator~(E e) {
-    return static_cast<E>(~ToValue(e));
+    return static_cast<E>(~std::to_underlying(e));
 }
 
 template <typename E>
@@ -68,26 +67,26 @@ template <typename E>
     requires std::is_enum_v<E>
 constexpr void SetFlag(uint32_t& flags, E bit, bool enable) {
     if (enable) {
-        flags |= ToValue(bit);
+        flags |= std::to_underlying(bit);
     } else {
-        flags &= ~ToValue(bit);
+        flags &= ~std::to_underlying(bit);
     }
 }
 
 template <typename E>
     requires std::is_enum_v<E>
 constexpr uint32_t SetFlagValue(uint32_t flags, E bit, bool enable) {
     if (enable) {
-        return flags | ToValue(bit);
+        return flags | std::to_underlying(bit);
     }
 
-	return flags & ~ToValue(bit);
+	return flags & ~std::to_underlying(bit);
 }
 
 template <typename E>
     requires std::is_enum_v<E>
 constexpr bool IsFlagSet(uint32_t flags, E bit) {
-    return (flags & ToValue(bit)) != 0;
+    return (flags & std::to_underlying(bit)) != 0;
 }
 } // namespace common
 

common/include/common/utils/utils_flags.h

@@ -39,10 +39,10 @@ namespace debug::stack {
 inline static constexpr uint32_t kMagicWord = 0xABCDABCD;
 
 inline void Print() {
-	static uint32_t s_used_bytes_previous;
+    static uint32_t s_used_bytes_previous;
     const auto* start = reinterpret_cast<uint32_t*>(&stack_low);
     const auto* end = reinterpret_cast<uint32_t*>(&_sp);
-	assert(end > start);
+    assert(end > start);
     const auto kSize = static_cast<uint32_t>(end - start);
 
     const auto* ptr = start;
@@ -70,16 +70,25 @@ inline void Print() {
         }
 
 #ifndef NDEBUG
-        printf("Stack: Size %uKB, [%p:%p:%p], Used: %u, Free: %u [%u]", static_cast<unsigned>(kSize / (1024 / 4)), reinterpret_cast<const void *>(start), reinterpret_cast<const void *>(ptr), reinterpret_cast<const void *>(end), static_cast<unsigned>(kUsedBytes), static_cast<unsigned>(kFreeBytes), static_cast<unsigned>(kFreePct));
+        printf("Stack: Size %uKB, [%p:%p:%p], Used: %u, Free: %u [%u]", 
+			static_cast<unsigned>(kSize / (1024 / 4)), 
+			reinterpret_cast<const void*>(start), 
+			reinterpret_cast<const void*>(ptr), 
+			reinterpret_cast<const void*>(end),
+			static_cast<unsigned>(kUsedBytes), 
+			static_cast<unsigned>(kFreeBytes), 
+			static_cast<unsigned>(kFreePct));
 #else
-        printf("Stack: Size %uKB, Used: %u, Free: %u", static_cast<unsigned>(kSize / (1024 / 4)), static_cast<unsigned>(kUsedBytes), static_cast<unsigned>(kFreeBytes));
+        printf("Stack: Size %uKB, Used: %u, Free: %u", static_cast<unsigned>(kSize / (1024 / 4)), 
+			static_cast<unsigned>(kUsedBytes), 
+			static_cast<unsigned>(kFreeBytes));
 #endif
         printf("\x1b[39m\n");
     }
 }
 
 inline void Run() {
-	static uint32_t s_millis_previous;
+    static uint32_t s_millis_previous;
     const auto kMillis = timing::Millis();
     if (kMillis - s_millis_previous >= 1000U) {
         s_millis_previous = kMillis;