Code formatting and assert/message improvements

Reformat code and tighten checks across several modules:

- common/utils/utils_hex.h: Update copyright years; reformat namespace, functions and templates; compact FromChar; make FromHex stricter with a compile-time static_assert for invalid hex digits; minor whitespace and comment adjustments.
- lib-artnet/src/controller/artnetcontroller.cpp: Reflow braces and spacing, unify formatting, and simplify some expressions; no behavioral logic changes intended.
- lib-network/src/core/network_memory.h: Improve assert diagnostics for invalid pointers and double-free detection.
- lib-rdm/src/controller/rdm_discovery_statemachine.cpp: Reflow formatting, compact printf calls, and improve assert messages; cleanup namespace closing.

Overall these are stylistic and safety-focused changes; functionality should remain unchanged except for stricter compile-time checks in the hex utilities.

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_