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;

common/include/firmware/debug/debug_stack.h

@@ -35,7 +35,6 @@
 #include "dmxnodemsgconst.h"
 #include "artnettriggerhandler.h"
 #include "firmware/pixeldmx/show.h"
-#include "common/utils/utils_enum.h"
 #include "pixeltestpattern.h"
 #include "json/pixeldmxparams.h"
 #include "pixeldmxmulti.h"
@@ -54,8 +53,7 @@ void RebootHandler() {
 }
 } // namespace board
 
-int main() // NOLINT
-{
+int main() { // NOLINT
     board::Init();
     DisplayUdf display;
     ConfigStore config_store;

gd32_emac_artnet_pixel_multi/firmware/main.cpp

@@ -30,6 +30,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <utility>
 #if !defined(DISABLE_RTC)
 #include <ctime>
 #endif
@@ -40,7 +41,6 @@
 #include "artnet.h"
 #include "artnetdisplay.h"
 #include "artnetstore.h"
-#include "common/utils/utils_enum.h"
 #if defined(ARTNET_HAVE_TRIGGER)
 #include "artnettrigger.h"
 #endif
@@ -87,7 +87,7 @@ ArtNetNode::ArtNetNode() {
 
     memset(&art_poll_reply_, 0, sizeof(struct artnet::ArtPollReply));
     memcpy(art_poll_reply_.id, artnet::kNodeId, sizeof(art_poll_reply_.id));
-    art_poll_reply_.op_code = common::ToValue(artnet::OpCodes::kOpPollreply);
+    art_poll_reply_.op_code = std::to_underlying(artnet::OpCodes::kOpPollreply);
     art_poll_reply_.port = artnet::kUdpPort;
     art_poll_reply_.vers_info_h = ArtNetConst::kVersion[0];
     art_poll_reply_.vers_info_l = ArtNetConst::kVersion[1];
@@ -138,7 +138,7 @@ ArtNetNode::ArtNetNode() {
 
 #if defined(ARTNET_HAVE_TIMECODE)
     memcpy(art_time_code_.id, artnet::kNodeId, sizeof(art_poll_reply_.id));
-    art_time_code_.op_code = common::ToValue(artnet::OpCodes::kOpTimecode);
+    art_time_code_.op_code = std::to_underlying(artnet::OpCodes::kOpTimecode);
     art_time_code_.prot_ver_hi = 0;
     art_time_code_.prot_ver_lo = artnet::kProtocolRevision;
     art_time_code_.filler1 = 0;
@@ -148,7 +148,7 @@ ArtNetNode::ArtNetNode() {
 #if defined(ARTNET_ENABLE_SENDDIAG)
     memset(&diag_data_, 0, sizeof(struct artnet::ArtDiagData));
     memcpy(diag_data_.id, artnet::kNodeId, sizeof(diag_data_.id));
-    diag_data_.op_code = common::ToValue(artnet::OpCodes::kOpDiagdata);
+    diag_data_.op_code = std::to_underlying(artnet::OpCodes::kOpDiagdata);
     diag_data_.prot_ver_lo = artnet::kProtocolRevision;
 #endif
 

lib-artnet/src/node/artnetnode.cpp

@@ -37,7 +37,6 @@
 #include "configurationstore.h"
 #include "common/utils/utils_flags.h"
 #include "common/utils/utils_array.h"
-#include "common/utils/utils_enum.h"
 #include "firmware/debug/debug_debug.h"
 #include "displayudf.h"
 
@@ -117,9 +116,9 @@ void DisplayUdfParams::SetAndShow() {
     for (uint8_t i = 0; i < common::ArraySize(DisplayUdfParamsConst::kLabels); ++i) {
         const auto kLabelIndex = store_displayudf.label_index[i];
         if (kLabelIndex != 0) {
-            displayudf.Set(kLabelIndex, common::FromValue<displayudf::Labels>(i));
+            displayudf.Set(kLabelIndex, static_cast<displayudf::Labels>(i));
         } else {
-            displayudf.Set(255, common::FromValue<displayudf::Labels>(i));
+            displayudf.Set(255, static_cast<displayudf::Labels>(i));
         }
     }
 

lib-displayudf/src/json/displayudfparams.cpp

@@ -28,6 +28,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <utility>
 
 #include "json/dmxnodeparams.h"
 #include "json/dmxnodeparamsconst.h"
@@ -39,7 +40,6 @@
 #include "configstore.h"
 #include "configurationstore.h"
 #include "common/utils/utils_flags.h"
-#include "common/utils/utils_enum.h"
 #include "firmware/debug/debug_debug.h"
 
 using common::store::dmxnode::Flags;
@@ -59,7 +59,7 @@ void DmxNodeParams::SetNodeName(const char* val, uint32_t len) {
 }
 
 void DmxNodeParams::SetFailsafe(const char* val, [[maybe_unused]] uint32_t len) {
-    store_dmxnode.fail_safe = common::ToValue(dmxnode::GetFailsafe(val));
+    store_dmxnode.fail_safe = std::to_underlying(dmxnode::GetFailsafe(val));
 }
 
 void DmxNodeParams::SetDisableMergeTimeout(const char* val, [[maybe_unused]] uint32_t len) {

lib-dmxnode/src/json/dmxnodeparams.cpp

@@ -28,10 +28,10 @@
 
 #include <cstdint>
 #include <cstdio>
+#include <utility>
 #include <cassert>
 
 #include "pixeltype.h"
-#include "common/utils/utils_enum.h"
 #if defined(CONFIG_PIXELDMX_ENABLE_GAMMATABLE)
 #include "gamma/gamma_tables.h"
 #endif
@@ -122,7 +122,7 @@ class PixelConfiguration {
 
         const auto& info = GetTypeInfo(type_);
 
-        leds_per_pixel_ = common::ToValue(info.led_count);
+        leds_per_pixel_ = std::to_underlying(info.led_count);
         is_rtz_protocol_ = info.protocol_type == pixel::ProtocolType::kRtz;
 
         if (map_ == pixel::LedMap::kUndefined) {