Refactor utils_hex.h formatting and validation

Update utils_hex.h with formatting and API cleanups: extend copyright year to 2026, collapse namespace/enum/function declarations to a more compact style, and tidy braces/spacing. Add stronger validation in FromHex by turning an invalid-nibble path into a compile-time failure (static_assert) instead of returning 0. Also minor refactors for ToString/ToStringLower/ToStringUpper and FromChar for brevity and consistency.

Author: vanvught

common/include/common/utils/utils_hex.h

@@ -2,7 +2,7 @@
  * @file utils_hex.h
  *
  */
-/* 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
@@ -30,41 +30,29 @@
 #include <cstddef>
 #include <cassert>
 
-namespace common::hex
-{
-constexpr char ToCharLowercase(uint32_t value)
-{
+namespace common::hex {
+constexpr char ToCharLowercase(uint32_t value) {
     return "0123456789abcdef"[value & 0xf];
 }
 
-constexpr char ToCharUppercase(uint32_t value)
-{
+constexpr char ToCharUppercase(uint32_t value) {
     return "0123456789ABCDEF"[value & 0xf];
 }
 
-enum class Case
-{
-    kLower,
-    kUpper
-};
+enum class Case { kLower, kUpper };
 
-template <Case letter_case = Case::kLower, size_t N> 
-char* ToString(char (&string)[N + 1], uint32_t value)
-{
+template <Case letter_case = Case::kLower, size_t N>
+char* ToString(char (&string)[N + 1], uint32_t value) {
     static_assert(N % 2 == 0, "Hex string length must be even");
     static_assert(N <= 8, "Cannot represent more than 32 bits");
 
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t i = 0; i < N; ++i) {
         size_t shift = (N - 1 - i) * 4;
         uint32_t nybble = (value >> shift);
 
-        if constexpr (letter_case == Case::kLower)
-        {
+        if constexpr (letter_case == Case::kLower) {
             string[i] = hex::ToCharLowercase(nybble);
-        }
-        else
-        {
+        } else {
             string[i] = hex::ToCharUppercase(nybble);
         }
     }
@@ -73,45 +61,36 @@ char* ToString(char (&string)[N + 1], uint32_t value)
     return string;
 }
 
-template <size_t N> 
-char* ToStringLower(char (&s)[N + 1], uint32_t v)
-{
+template <size_t N>
+char* ToStringLower(char (&s)[N + 1], uint32_t v) {
     return ToString<Case::kLower, N>(s, v);
 }
 
-template <size_t N> 
-char* ToStringUpper(char (&s)[N + 1], uint32_t v)
-{
+template <size_t N> char*
+ToStringUpper(char (&s)[N + 1], uint32_t v) {
     return ToString<Case::kUpper, N>(s, v);
 }
 
-constexpr uint8_t FromChar(char c)
-{
-    return (c >= '0' && c <= '9')   ? static_cast<uint8_t>(c - '0')
-           : (c >= 'a' && c <= 'f') ? static_cast<uint8_t>(c - 'a' + 10)
-           : (c >= 'A' && c <= 'F') ? static_cast<uint8_t>(c - 'A' + 10)
-                                    : 0xFF; // Invalid
+constexpr uint8_t FromChar(char c) {
+    return (c >= '0' && c <= '9') ? static_cast<uint8_t>(c - '0') : (c >= 'a' && c <= 'f') ? static_cast<uint8_t>(c - 'a' + 10) : (c >= 'A' && c <= 'F') ? static_cast<uint8_t>(c - 'A' + 10) : 0xFF; // Invalid
 }
 
-template <size_t N> constexpr uint32_t FromHex(const char (&string)[N])
-{
+template <size_t N> 
+constexpr uint32_t FromHex(const char (&string)[N]) {
     static_assert(N > 1, "Hex string must not be empty (must include \\0)");
     static_assert(N <= 9, "Too many hex digits for uint32_t");
     assert(string[N - 1] == '\0');
 
     uint32_t result = 0;
-    for (size_t i = 0; i < N - 1; ++i)
-    {
+    for (size_t i = 0; i < N - 1; ++i) {
         const uint8_t kNibble = FromChar(string[i]);
-        if (kNibble == 0xFF)
-        {
-            return 0; // Or: static_assert(false, "Invalid hex digit"); if desired
+        if constexpr (kNibble == 0xFF) {
+            static_assert(false, "Invalid hex digit");
         }
         result = (result << 4) | kNibble;
     }
     return result;
 }
-
 } // namespace common::hex
 
-#endif  // COMMON_UTILS_UTILS_HEX_H_
+#endif // COMMON_UTILS_UTILS_HEX_H_