Refactor main function to improve error handling and parsing of chrono time (#8)

* Refactor main function to improve error handling and parsing of chrono time

* Refactor parse functions to improve error handling and consistency in parameter naming

* Refactor check_range and get_time functions for improved type safety and readability; update parse function to use consistent time_struct variable.

* Add clang-format ignore comment for improved formatting control

* Remove specific NOLINTNEXTLINE comment for improved readability in mktime function

Author: mguludag

example/main.cpp

@@ -1,12 +1,20 @@
 #include "mgutility/chrono/parse.hpp"
 
+// trunk-ignore-all(clang-format)
+
 // {fmt} for printing
 #include <fmt/chrono.h>
 #include <fmt/format.h>
 
 int main() {
-  const auto chrono_time =
-      mgutility::chrono::parse("{:%FT%T.%f%z}", "2023-04-16T00:05:23.999+0100");
+  auto chrono_time = std::chrono::system_clock::time_point{};
+  const auto error =
+      mgutility::chrono::parse(chrono_time, "{:%FT%T.%f%z}", "2023-04-16T00:05:23.999+0100");
+
+  if (error) {
+    fmt::print("Error: {}\n", error.message());
+    return 1;
+  }
 
   fmt::print("{:%F %T}\n", chrono_time); // prints 2023-04-15 23:05:23.999000000
                                          // ({fmt} trunk version)

include/mgutility/chrono/parse.hpp

@@ -36,9 +36,11 @@
 #include <stdexcept>
 #include <type_traits>
 
+//NOLINTBEGIN(modernize-concat-nested-namespaces)
 namespace mgutility {
 namespace chrono {
 namespace detail {
+//NOLINTEND(modernize-concat-nested-namespaces)
 
 /**
  * @brief Extended tm structure with milliseconds.
@@ -61,8 +63,6 @@ template <typename T = int32_t>
 MGUTILITY_CNSTXPR auto parse_integer(T &result, mgutility::string_view str,
                                      uint32_t len, uint32_t &next,
                                      uint32_t begin_offset = 0) -> std::errc {
-  result = 0;
-
   auto error = mgutility::from_chars(str.data() + next + begin_offset,
                                      str.data() + len + next, result);
 
@@ -79,8 +79,8 @@ MGUTILITY_CNSTXPR auto parse_integer(T &result, mgutility::string_view str,
  * @param max The maximum acceptable value.
  * @throws std::out_of_range if the value is out of range.
  */
-MGUTILITY_CNSTXPR auto check_range(int32_t value, int32_t min, int32_t max)
-    -> std::errc {
+ template <typename T = int32_t>
+MGUTILITY_CNSTXPR auto check_range(const T& value, const int32_t& min, const int32_t& max) -> std::errc {
   if (value < min || value > max) {
     return std::errc::result_out_of_range;
   }
@@ -104,7 +104,7 @@ auto MGUTILITY_CNSTXPR is_leap_year(uint32_t year) -> bool {
  * @return std::time_t The corresponding time_t value.
  * @throws std::out_of_range if any tm value is out of valid range.
  */
-MGUTILITY_CNSTXPR auto mktime(std::time_t &result, std::tm &tm) -> std::errc {
+MGUTILITY_CNSTXPR auto mktime(std::time_t &result, std::tm &time_struct) -> std::errc {
   MGUTILITY_CNSTXPR std::array<std::array<uint32_t, 12>, 2> num_of_days{
       {{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,
         31}, // 365 days in a common year
@@ -114,30 +114,31 @@ MGUTILITY_CNSTXPR auto mktime(std::time_t &result, std::tm &tm) -> std::errc {
   result = 0;
 
   // Check for out of range values in tm structure
-  if (tm.tm_mon > 12 || tm.tm_mon < 0 || tm.tm_mday > 31 || tm.tm_min > 60 ||
-      tm.tm_sec > 60 || tm.tm_hour > 24) {
+  if (time_struct.tm_mon > 12 || time_struct.tm_mon < 0 || time_struct.tm_mday > 31 || time_struct.tm_min > 60 ||
+      time_struct.tm_sec > 60 || time_struct.tm_hour > 24) {
     return std::errc::result_out_of_range;
   }
 
-  tm.tm_year += 1900;
+  time_struct.tm_year += 1900;
 
   // Calculate the number of days since 1970
-  for (auto i{1970}; i < tm.tm_year; ++i) {
+  for (auto i{1970}; i < time_struct.tm_year; ++i) {
     result += is_leap_year(i) ? 366 : 365;
   }
 
   // Add the days for the current year
-  for (auto i{0}; i < tm.tm_mon; ++i) {
-    result += num_of_days[is_leap_year(tm.tm_year)][i];
+  for (auto i{0}; i < time_struct.tm_mon; ++i) {
+    //NOLINTNEXTLINE
+    result += num_of_days[is_leap_year(time_struct.tm_year)][i];
   }
 
-  result += tm.tm_mday - 1; // nth day since 1970
+  result += time_struct.tm_mday - 1; // nth day since 1970
   result *= 24;
-  result += tm.tm_hour;
+  result += time_struct.tm_hour;
   result *= 60;
-  result += tm.tm_min;
+  result += time_struct.tm_min;
   result *= 60;
-  result += tm.tm_sec;
+  result += time_struct.tm_sec;
 
   return std::errc{};
 }
@@ -148,56 +149,52 @@ MGUTILITY_CNSTXPR auto mktime(std::time_t &result, std::tm &tm) -> std::errc {
  * @param tm The tm structure to adjust.
  * @param offset The timezone offset in hours and minutes.
  */
-MGUTILITY_CNSTXPR auto handle_timezone(tm &tm, int32_t offset) -> void {
+MGUTILITY_CNSTXPR auto handle_timezone(tm &time_struct, int32_t offset) -> void {
   const auto minute = offset % 100;
   const auto hour = offset / 100;
 
   if (offset < 0) {
-    // Adjust minutes
-    if (tm.tm_min + minute < 0) {
-      tm.tm_min += 60 - minute;
-      tm.tm_hour -= 1;
-      if (tm.tm_hour < 0) {
-        tm.tm_hour += 24;
-        tm.tm_mday -= 1;
+    if (time_struct.tm_min + minute < 0) {
+      time_struct.tm_min += 60 - minute;
+      time_struct.tm_hour -= 1;
+      if (time_struct.tm_hour < 0) {
+        time_struct.tm_hour += 24;
+        time_struct.tm_mday -= 1;
       }
     } else {
-      tm.tm_min += minute;
+      time_struct.tm_min += minute;
     }
 
-    // Adjust hours
-    if (tm.tm_hour + hour < 0) {
-      tm.tm_hour += 24 + hour;
-      tm.tm_mday -= 1;
+    if (time_struct.tm_hour + hour < 0) {
+      time_struct.tm_hour += 24 + hour;
+      time_struct.tm_mday -= 1;
     } else {
-      tm.tm_hour += hour;
+      time_struct.tm_hour += hour;
     }
   } else {
-    // Adjust minutes
-    if (tm.tm_min + minute >= 60) {
-      tm.tm_min -= 60 - minute;
-      tm.tm_hour += 1;
-      if (tm.tm_hour >= 24) {
-        tm.tm_hour -= 24;
-        tm.tm_mday += 1;
+    if (time_struct.tm_min + minute >= 60) {
+      time_struct.tm_min -= 60 - minute;
+      time_struct.tm_hour += 1;
+      if (time_struct.tm_hour >= 24) {
+        time_struct.tm_hour -= 24;
+        time_struct.tm_mday += 1;
       }
     } else {
-      tm.tm_min += minute;
+      time_struct.tm_min += minute;
     }
 
-    // Adjust hours
-    if (tm.tm_hour + hour >= 24) {
-      tm.tm_hour += hour - 24;
-      tm.tm_mday += 1;
-      if (tm.tm_mon == 11 && tm.tm_mday > 31) { // Handle December overflow
-        tm.tm_mday = 1;
-        tm.tm_mon = 0;
-      } else if (tm.tm_mday > 30) { // Handle month overflow for other months
-        tm.tm_mday = 1;
-        tm.tm_mon += 1;
+    if (time_struct.tm_hour + hour >= 24) {
+      time_struct.tm_hour += hour - 24;
+      time_struct.tm_mday += 1;
+      if (time_struct.tm_mon == 11 && time_struct.tm_mday > 31) {
+        time_struct.tm_mday = 1;
+        time_struct.tm_mon = 0;
+      } else if (time_struct.tm_mday > 30) {
+        time_struct.tm_mday = 1;
+        time_struct.tm_mon += 1;
       }
     } else {
-      tm.tm_hour += hour;
+      time_struct.tm_hour += hour;
     }
   }
 }
@@ -220,34 +217,49 @@ MGUTILITY_CNSTXPR auto parse_month(detail::tm &result, string_view date_str,
 MGUTILITY_CNSTXPR auto parse_day(detail::tm &result, string_view date_str,
                                  uint32_t &next) -> std::errc {
   auto error = parse_integer(result.tm_mday, date_str, 2, next);
+  if (error != std::errc{}) {
+    return error;
+  }
   error = check_range(result.tm_mday, 1, 31);
   return error;
 }
 
 MGUTILITY_CNSTXPR auto parse_hour(detail::tm &result, string_view date_str,
                                   uint32_t &next) -> std::errc {
   auto error = parse_integer(result.tm_hour, date_str, 2, next);
+  if (error != std::errc{}) {
+    return error;
+  }
   error = check_range(result.tm_hour, 0, 23);
   return error;
 }
 
 MGUTILITY_CNSTXPR auto parse_minute(detail::tm &result, string_view date_str,
                                     uint32_t &next) -> std::errc {
   auto error = parse_integer(result.tm_min, date_str, 2, next);
+  if (error != std::errc{}) {
+    return error;
+  }
   error = check_range(result.tm_min, 0, 59);
   return error;
 }
 
 MGUTILITY_CNSTXPR auto parse_second(detail::tm &result, string_view date_str,
                                     uint32_t &next) -> std::errc {
   auto error = parse_integer(result.tm_sec, date_str, 2, next);
+  if (error != std::errc{}) {
+    return error;
+  }
   error = check_range(result.tm_sec, 0, 59);
   return error;
 }
 
 MGUTILITY_CNSTXPR auto parse_fraction(detail::tm &result, string_view date_str,
                                       uint32_t &next) -> std::errc {
   auto error = parse_integer(result.tm_ms, date_str, 3, next);
+  if (error != std::errc{}) {
+    return error;
+  }
   error = check_range(result.tm_ms, 0, 999);
   return error;
 }
@@ -264,27 +276,25 @@ MGUTILITY_CNSTXPR auto parse_timezone_offset(detail::tm &result, string_view dat
     return std::errc::invalid_argument;
   }
 
-  char sign = date_str[next++];
-  int32_t hour = 0, minute = 0;
+  const char sign = date_str[next++];
+  int32_t hour = 0;
+  int32_t minute = 0;
 
-  // Parse hour part (2 digits)
   error = parse_integer(hour, date_str, 2, next);
   if (error != std::errc{}) {
     return error;
   }
 
-  // Optional colon
   if (next < date_str.size() && date_str[next] == ':') {
     ++next;
   }
 
-  // Parse minute part (2 digits)
   error = parse_integer(minute, date_str, 2, next);
   if (error != std::errc{}) {
     return error;
   }
 
-  int32_t offset = hour * 100 + minute;
+  const int32_t offset = hour * 100 + minute;
   error = check_range(offset, 0, 1200);
   if (error != std::errc{}) {
     return error;
@@ -305,61 +315,64 @@ MGUTILITY_CNSTXPR auto parse_timezone_offset(detail::tm &result, string_view dat
  */
 MGUTILITY_CNSTXPR auto get_time(detail::tm &result, string_view format,
                                 string_view date_str) -> std::errc {
-  int32_t count{0};
-  std::size_t begin{0}, end{0};
-
-  // Find the positions of format specifiers
-  begin = format.find('{');
-  end = format.find('}');
-  if (begin == string_view::npos || end == string_view::npos || begin >= end)
+  const std::size_t begin = format.find('{');
+  const std::size_t end = format.find('}');
+  if (begin == string_view::npos || end == string_view::npos || begin >= end) {
     return std::errc::invalid_argument;
+  }
 
-  if (format[begin + 1] != ':' || (end - begin < 3 || count != 0))
+  if (format[begin + 1] != ':' || (end - begin < 3)) {
     return std::errc::invalid_argument;
+  }
 
-  uint32_t next{0};
+  uint32_t next = 0;
   std::errc error{};
 
-  // Parse the date and time string based on the format specifiers
-  for (auto i{begin}; i < end; ++i) {
+  for (std::size_t i = begin; i < end; ++i) {
     switch (format[i]) {
     case '%': {
       if (i + 1 >= format.size()) {
         return std::errc::invalid_argument;
       }
       switch (format[i + 1]) {
-      case 'Y': // Year with century (4 digits)
+      case 'Y':
         error = parse_year(result, date_str, next);
         break;
-      case 'm': // Month (01-12)
+      case 'm':
         error = parse_month(result, date_str, next);
         break;
-      case 'd': // Day of the month (01-31)
+      case 'd':
         error = parse_day(result, date_str, next);
         break;
-      case 'F': { // Full date (YYYY-MM-DD)
+      case 'F': {
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_year(result, date_str, next);
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_month(result, date_str, next);
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_day(result, date_str, next);
       } break;
-      case 'H': // Hour (00-23)
+      case 'H':
         error = parse_hour(result, date_str, next);
         break;
-      case 'M': // Minute (00-59)
+      case 'M':
         error = parse_minute(result, date_str, next);
         break;
-      case 'S': // Second (00-59)
+      case 'S':
         error = parse_second(result, date_str, next);
         break;
-      case 'T': { // Full time (HH:MM:SS)
+      case 'T': {
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_hour(result, date_str, next);
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_minute(result, date_str, next);
+        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
         error = parse_second(result, date_str, next);
       } break;
-      case 'f': // Milliseconds (000-999)
+      case 'f':
         error = parse_fraction(result, date_str, next);
         break;
-      case 'z': { // Timezone offset (+/-HHMM)
+      case 'z': {
         error = parse_timezone_offset(result, date_str, next);
       } break;
       default:
@@ -399,18 +412,18 @@ MGUTILITY_CNSTXPR auto get_time(detail::tm &result, string_view format,
 template <typename Clock = std::chrono::system_clock>
 auto parse(typename Clock::time_point &time_point, string_view format,
            string_view date_str) -> std::error_code {
-  detail::tm tm{};
-  auto error = detail::get_time(tm, format, date_str);
+  detail::tm time_struct{};
+  auto error = detail::get_time(time_struct, format, date_str);
   if (error != std::errc{}) {
     return std::make_error_code(error);
   }
   std::time_t time_t{};
-  error = detail::mktime(time_t, tm);
+  error = detail::mktime(time_t, time_struct);
   if (error != std::errc{}) {
     return std::make_error_code(error);
   }
   time_point = Clock::from_time_t(time_t);
-  time_point += std::chrono::milliseconds(tm.tm_ms);
+  time_point += std::chrono::milliseconds(time_struct.tm_ms);
   return std::error_code{};
 }
 

include/mgutility/std/charconv.hpp

@@ -65,7 +65,7 @@ constexpr auto char_to_int(char c) noexcept -> int {
  * @param value Reference to an integer where the parsed value will be stored.
  * @return from_chars_result The result of the parsing operation.
  */
- template <typename T = int32_t>
+template <typename T = int32_t>
 MGUTILITY_CNSTXPR auto from_chars(const char *first, const char *last,
                                   T &value) noexcept -> from_chars_result {
   T result = 0;