Raise common code to C++23

Update shared utility headers for C++23 formatting and syntax cleanup, and switch the common build flags from C++20 to C++23. Also tighten a few UTC offset calculations and simplify inline helpers in `global.h`.

Author: vanvught

common/include/common/utils/utils_enum.h

@@ -28,8 +28,7 @@
 
 #include <type_traits>
 
-namespace common
-{
+namespace common {
 // Converts an enum class value to its underlying integer type.
 template <typename Enum> 
 constexpr auto ToValue(Enum e) noexcept -> std::underlying_type_t<Enum> {

common/include/common/utils/utils_flags.h

@@ -31,80 +31,64 @@
 
 #include "common/utils/utils_enum.h" // Ensure this provides ToValue and FromValue
 
-namespace common
-{
-
+namespace common {
 template <typename E>
     requires std::is_enum_v<E>
-constexpr E operator|(E lhs, E rhs)
-{
+constexpr E operator|(E lhs, E rhs) {
     return static_cast<E>(ToValue(lhs) | ToValue(rhs));
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr E operator&(E lhs, E rhs)
-{
+constexpr E operator&(E lhs, E rhs) {
     return static_cast<E>(ToValue(lhs) & ToValue(rhs));
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr E operator~(E e)
-{
+constexpr E operator~(E e) {
     return static_cast<E>(~ToValue(e));
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr E& operator|=(E& lhs, E rhs)
-{
+constexpr E& operator|=(E& lhs, E rhs) {
     lhs = lhs | rhs;
     return lhs;
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr E& operator&=(E& lhs, E rhs)
-{
+constexpr E& operator&=(E& lhs, E rhs) {
     lhs = lhs & rhs;
     return lhs;
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr void SetFlag(uint32_t& flags, E bit, bool enable)
-{
-    if (enable)
-    {
+constexpr void SetFlag(uint32_t& flags, E bit, bool enable) {
+    if (enable) {
         flags |= ToValue(bit);
-    }
-    else
-    {
+    } else {
         flags &= ~ToValue(bit);
     }
 }
 
 template <typename E>
     requires std::is_enum_v<E>
-constexpr uint32_t SetFlagValue(uint32_t flags, E bit, bool enable)
-{
-    if (enable)
-    {
+constexpr uint32_t SetFlagValue(uint32_t flags, E bit, bool enable) {
+    if (enable) {
         return flags | ToValue(bit);
     }
-    else
-    {
-        return flags & ~ToValue(bit);
-    }
+         
+	return flags & ~ToValue(bit);
 }
 
 template <typename E>
-requires std::is_enum_v<E>
+    requires std::is_enum_v<E>
 constexpr bool IsFlagSet(uint32_t flags, E bit) {
     return (flags & ToValue(bit)) != 0;
 }
-
 } // namespace common
 
-#endif  // COMMON_UTILS_UTILS_FLAGS_H_
+#endif // COMMON_UTILS_UTILS_FLAGS_H_

common/include/common/utils/utils_hash.h

@@ -29,27 +29,23 @@
 #include <cstdint>
 
 // Compile-time FNV-1a 32-bit hash
-consteval uint32_t Fnv1a32(const char* str, uint8_t length)
-{
+consteval uint32_t Fnv1a32(const char* str, uint8_t length) {
     uint32_t hash = 0x811c9dc5u;
-    for (uint8_t i = 0; i < length; ++i)
-    {
+    for (uint8_t i = 0; i < length; ++i) {
         hash ^= static_cast<uint8_t>(str[i]);
         hash *= 0x01000193u;
     }
     return hash;
 }
 
 // Runtime version for raw filenames
-inline uint32_t Fnv1a32Runtime(const char* str, uint32_t length)
-{
+inline uint32_t Fnv1a32Runtime(const char* str, uint32_t length) {
     uint32_t hash = 0x811c9dc5u;
-    for (uint32_t i = 0; i < length; ++i)
-    {
+    for (uint32_t i = 0; i < length; ++i) {
         hash ^= static_cast<uint8_t>(str[i]);
         hash *= 0x01000193u;
     }
     return hash;
 }
 
-#endif  // COMMON_UTILS_UTILS_HASH_H_
+#endif // COMMON_UTILS_UTILS_HASH_H_

common/include/common/utils/utils_port.h

@@ -28,18 +28,17 @@
 
 #include <cstdint>
 
-namespace common
-{
-template <class S> void PortSet(uint32_t port_index, S s, uint16_t& n)
-{
+namespace common {
+template <class S> 
+void PortSet(uint32_t port_index, S s, uint16_t& n) {
     uint16_t value = n; // Create a local copy
     value &= static_cast<uint16_t>(~(0x3 << (port_index * 2)));
     value |= static_cast<uint16_t>((static_cast<uint32_t>(s) & 0x3) << (port_index * 2));
     n = value; // Write back to the original field
 }
 
-template <class S> S PortGet(uint32_t port_index, uint16_t n)
-{
+template <class S> 
+S PortGet(uint32_t port_index, uint16_t n) {
     return static_cast<S>((n >> (port_index * 2)) & 0x3);
 }
 } // namespace common

common/include/common/utils/utils_string.h

@@ -28,13 +28,10 @@
 
 #include <cstdint>
 
-namespace common
-{
-constexpr uint32_t ConstStrLen(const char* s)
-{
+namespace common {
+constexpr uint32_t ConstStrLen(const char* str) {
     uint32_t len = 0;
-    while (s[len] != '\0')
-    {
+    while (str[len] != '\0') {
         ++len;
     }
     return len;

common/include/global.h

@@ -16,14 +16,6 @@
 
 #include "utc.h"
 
-/**
- * @namespace global
- * @brief Contains global variables related to time configuration.
- */
-namespace global {
-extern int32_t g_utc_offset;
-}
-
 /**
  * @class Global
  * @brief Singleton class for managing and validating UTC offsets.
@@ -53,14 +45,14 @@ class Global {
      * @param[out] hours Signed hour component.
      * @param[out] minutes Unsigned minute component.
      */
-    inline void GetUtcOffset(int32_t& hours, uint32_t& minutes) { utc::SplitOffset(global::g_utc_offset, hours, minutes); }
+    void GetUtcOffset(int32_t& hours, uint32_t& minutes) { utc::SplitOffset(global::g_utc_offset, hours, minutes); }
 
     /**
      * @brief Sets the global UTC offset if the value is valid.
      * @param utc_offset_seconds Offset in seconds
      * @return true if successfully set; false otherwise
      */
-    inline bool SetUtcOffsetIfValid(int32_t utc_offset_seconds) {
+    bool SetUtcOffsetIfValid(int32_t utc_offset_seconds) {
         if (utc::IsValidOffset(utc_offset_seconds)) {
             ::global::g_utc_offset = utc_offset_seconds;
             return true;
@@ -74,7 +66,7 @@ class Global {
      * @param minutes Unsigned minute component
      * @return true if valid and set; false otherwise
      */
-    inline bool SetUtcOffsetIfValid(int32_t hours, uint32_t minutes) {
+    bool SetUtcOffsetIfValid(int32_t hours, uint32_t minutes) {
         int32_t offset_seconds;
         if (utc::ValidateOffset(hours, minutes, offset_seconds)) {
             return SetUtcOffsetIfValid(offset_seconds);

common/include/utc.h

@@ -73,7 +73,7 @@ inline bool ValidateOffset(int32_t hours, uint32_t minutes, int32_t& utc_offset_
         }
         for (const auto& offset : kValidOffsets) {
             if (offset.hours == hours && offset.minutes == minutes) {
-                utc_offset_seconds = (hours >= 0) ? (hours * 3600 + static_cast<int32_t>(minutes) * 60) : (hours * 3600 - static_cast<int32_t>(minutes) * 60);
+                utc_offset_seconds = (hours >= 0) ? ((hours * 3600) + static_cast<int32_t>(minutes) * 60) : (hours * 3600 - static_cast<int32_t>(minutes) * 60);
                 return true;
             }
         }
@@ -87,7 +87,9 @@ inline bool ValidateOffset(int32_t hours, uint32_t minutes, int32_t& utc_offset_
  * @return true if offset is valid; false otherwise
  */
 inline bool IsValidOffset(int32_t utc_offset_seconds) {
-    if (utc_offset_seconds == 0) return true;
+    if (utc_offset_seconds == 0) {
+        return true;
+    }
     int32_t hours = utc_offset_seconds / 3600;
     uint32_t minutes = (utc_offset_seconds >= 0) ? static_cast<uint32_t>(utc_offset_seconds - hours * 3600) / 60 : static_cast<uint32_t>((hours * 3600 - utc_offset_seconds)) / 60;
 
@@ -96,8 +98,10 @@ inline bool IsValidOffset(int32_t utc_offset_seconds) {
     }
 
     for (const auto& offset : kValidOffsets) {
-        int32_t offset_seconds = (offset.hours >= 0) ? offset.hours * 3600 + static_cast<int32_t>(offset.minutes * 60) : offset.hours * 3600 - static_cast<int32_t>(offset.minutes * 60);
-        if (utc_offset_seconds == offset_seconds) return true;
+        int32_t offset_seconds = (offset.hours >= 0) ? (offset.hours * 3600) + static_cast<int32_t>(offset.minutes * 60) : offset.hours * 3600 - static_cast<int32_t>(offset.minutes * 60);
+        if (utc_offset_seconds == offset_seconds) {
+            return true;
+        }
     }
     return false;
 }
@@ -149,9 +153,13 @@ inline bool ParseOffset(const char* buffer, uint32_t buffer_length, int32_t& hou
     if (buffer[5] < '0' || buffer[5] > '9') return false;
 
     int32_t h = (buffer[1] - '0') * 10 + (buffer[2] - '0');
-    if (h > 14) return false;
+    if (h > 14) {
+        return false;
+    }
     uint32_t m = static_cast<uint32_t>((buffer[4] - '0') * 10 + (buffer[5] - '0'));
-    if (m >= 60) return false;
+    if (m >= 60) {
+        return false;
+    }
 
     hours = negative ? -h : h;
     minutes = m;

common/make/CppOps.mk

@@ -1,6 +1,6 @@
 $(info "CppOpts.mk")
 
-CPPOPS=-std=c++20
+CPPOPS=-std=c++23
 CPPOPS+=-Wnon-virtual-dtor -Woverloaded-virtual -Wnull-dereference -fno-rtti -fno-exceptions -fno-unwind-tables
 CPPOPS+=-Wuseless-cast -Wold-style-cast
 CPPOPS+=-fno-threadsafe-statics -fno-use-cxa-atexit