zoned_time

Author: LukashonakV

CMakeLists.txt

@@ -265,6 +265,50 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   set(WERROR_FLAG -Werror)
 endif ()
 
+include(CheckCXXSourceCompiles)
+
+# Check if compiler supports C++20
+check_cxx_compiler_flag("-std=c++20" HAVE_CXX20_FLAG)
+
+if (HAVE_CXX20_FLAG)
+  set(CMAKE_REQUIRED_FLAGS "-std=c++20")
+  set(FMT_HAVE_STD_ZONED_TIME_TEST
+"#include <chrono>
+#if !defined(__cpp_lib_chrono) || __cpp_lib_chrono < 201907L
+#error \"zoned_time not available\"
+#endif
+int main() {
+  using namespace std::chrono;
+  zoned_time<std::chrono::seconds> zt;
+  return 0;
+}
+")
+  check_cxx_source_compiles("${FMT_HAVE_STD_ZONED_TIME_TEST}" FMT_HAS_STD_ZONED_TIME)
+else ()
+  set(FMT_HAS_STD_ZONED_TIME OFF)
+  message(STATUS "C++20 not supported, zoned_time disabled")
+endif ()
+
+check_cxx_source_compiles("${FMT_HAVE_STD_ZONED_TIME_TEST}" FMT_HAS_STD_ZONED_TIME)
+
+if (FMT_HAS_STD_ZONED_TIME)
+  # Ensure we set the macro for both the library target and the header-only target.
+  foreach (tgt IN LISTS INSTALL_TARGETS)
+    if (TARGET ${tgt})
+      if ("${tgt}" STREQUAL "fmt-header-only")
+        # header-only target: INTERFACE definition is propagated to consumers
+        target_compile_definitions(${tgt} INTERFACE FMT_HAS_STD_ZONED_TIME=1)
+      else ()
+        # library target: PUBLIC so it's visible to dependents as well
+        target_compile_definitions(${tgt} PUBLIC FMT_HAS_STD_ZONED_TIME=1)
+      endif ()
+    endif ()
+  endforeach ()
+else ()
+  # Optional: provide a global fallback so that builds relying on a global define still see it.
+  # add_compile_definitions(FMT_HAS_STD_ZONED_TIME=1)  # usually not needed; prefer target-specific defs
+endif ()
+
 if (MSVC)
   set(PEDANTIC_COMPILE_FLAGS /W3)
   set(WERROR_FLAG /WX)

include/fmt/chrono.h

@@ -265,6 +265,11 @@ using utc_time = std::chrono::time_point<detail::utc_clock, Duration>;
 template <class Duration>
 using local_time = std::chrono::time_point<detail::local_t, Duration>;
 
+#if defined(FMT_HAS_STD_ZONED_TIME)
+template <typename Duration, typename TimeZonePtr>
+using zoned_time = std::chrono::zoned_time<Duration, TimeZonePtr>;
+#endif
+
 namespace detail {
 
 // Prevents expansion of a preceding token as a function-style macro.
@@ -2240,6 +2245,42 @@ struct formatter<local_time<Duration>, Char>
   }
 };
 
+#if defined(FMT_HAS_STD_ZONED_TIME)
+template <typename Duration, typename TimeZonePtr, typename Char>
+struct formatter<zoned_time<Duration, TimeZonePtr>, Char,
+                 std::enable_if_t<std::is_pointer_v<TimeZonePtr>>>
+    : private formatter<std::tm, Char> {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+    return this->do_parse(ctx, true);
+  }
+
+  template <typename FormatContext>
+  auto format(const std::chrono::zoned_time<Duration, TimeZonePtr>& val,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto time_info = val.get_info();
+    auto time_since_epoch = val.get_local_time().time_since_epoch();
+    auto seconds_since_epoch =
+        detail::duration_cast<std::chrono::seconds>(time_since_epoch);
+    // Use gmtime to prevent time zone conversion since local_time has an
+    // unspecified time zone.
+    std::tm t = gmtime(seconds_since_epoch.count());
+    // Create a custom tm with timezone info if supported
+    if constexpr (detail::has_tm_zone<std::tm>::value) {
+      t.tm_zone = time_info.abbrev.c_str();
+      t.tm_gmtoff = time_info.offset.count();
+    }
+    using period = typename Duration::period;
+    if (period::num == 1 && period::den == 1 &&
+        !std::is_floating_point<typename Duration::rep>::value) {
+      return formatter<std::tm, Char>::format(t, ctx);
+    }
+    auto subsecs =
+        detail::duration_cast<Duration>(time_since_epoch - seconds_since_epoch);
+    return formatter<std::tm, Char>::do_format(t, ctx, &subsecs);
+  }
+};
+#endif
+
 FMT_END_EXPORT
 FMT_END_NAMESPACE