Added support for subsecond resolution for time_point

include/fmt/chrono.h

@@ -405,13 +405,33 @@ inline size_t strftime(wchar_t* str, size_t count, const wchar_t* format,
 
 FMT_END_DETAIL_NAMESPACE
 
-template <typename Char, typename Duration>
-struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
+template <typename Char, typename Rep, typename Period>
+struct formatter<std::chrono::time_point<std::chrono::system_clock, std::chrono::duration<Rep, Period>>,
                  Char> : formatter<std::tm, Char> {
   template <typename FormatContext>
   auto format(std::chrono::time_point<std::chrono::system_clock> val,
               FormatContext& ctx) -> decltype(ctx.out()) {
-    std::tm time = localtime(val);
+    std::tm time;
+    auto epoch = val.time_since_epoch();
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch);
+    auto subseconds = std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(epoch - seconds);
+
+    if (subseconds < subseconds.zero()) {
+      time = localtime(val - std::chrono::seconds{1});
+      subseconds = std::chrono::seconds{1} + subseconds;
+    } else {
+      time = localtime(val);
+    }
+
+    if (subseconds.count() > 0) {
+      auto width = std::to_string(Period::den).size() - 1;
+      std::basic_stringstream<Char> os;
+      os.fill('0');
+      os.width(width);
+      os << subseconds.count();
+      auto formatted_ss = os.str();
+      return formatter<std::tm, Char>::format(time, ctx, formatted_ss);
+    }
     return formatter<std::tm, Char>::format(time, ctx);
   }
 };
@@ -428,14 +448,21 @@ template <typename Char> struct formatter<std::tm, Char> {
   }
 
   template <typename FormatContext>
-  auto format(const std::tm& tm, FormatContext& ctx) const
+  auto format(const std::tm& tm, FormatContext& ctx, const std::basic_string<Char> subseconds = {}) const
       -> decltype(ctx.out()) {
     basic_memory_buffer<Char> tm_format;
     tm_format.append(specs.begin(), specs.end());
     // By appending an extra space we can distinguish an empty result that
     // indicates insufficient buffer size from a guaranteed non-empty result
     // https://github.com/fmtlib/fmt/issues/2238
-    tm_format.push_back(' ');
+    auto hasS = std::find(tm_format.begin(), tm_format.end(), 'S') != tm_format.end();
+    auto hasT = std::find(tm_format.begin(), tm_format.end(), 'T') != tm_format.end();
+    auto writeSubseconds = (hasS || hasT) && (subseconds.size() > 0);
+    if (writeSubseconds)
+      // should be std::use_facet<std::numpunct<Char>>(locale).decimal_point();
+      tm_format.push_back('.');
+    else
+      tm_format.push_back(' ');
     tm_format.push_back('\0');
     basic_memory_buffer<Char> buf;
     size_t start = buf.size();
@@ -449,8 +476,15 @@ template <typename Char> struct formatter<std::tm, Char> {
       const size_t MIN_GROWTH = 10;
       buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
+
+    auto buf_end = buf.end() - 1;
+    if (writeSubseconds) {
+      buf.append(subseconds);
+      buf_end = buf.end();
+    }
+
     // Remove the extra space.
-    return std::copy(buf.begin(), buf.end() - 1, ctx.out());
+    return std::copy(buf.begin(), buf_end, ctx.out());
   }
 
   basic_string_view<Char> specs;

test/chrono-test.cc

@@ -94,12 +94,16 @@ template <typename TimePoint> auto strftime(TimePoint tp) -> std::string {
 }
 
 TEST(chrono_test, time_point) {
-  auto t1 = std::chrono::system_clock::now();
+  auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(std::chrono::system_clock::now());
   EXPECT_EQ(strftime(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
   using time_point =
       std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
   auto t2 = time_point(std::chrono::seconds(42));
   EXPECT_EQ(strftime(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
+  using time_point_2 = std::chrono::time_point<std::chrono::system_clock,
+                                               std::chrono::milliseconds>;
+  auto t3 = time_point_2(std::chrono::milliseconds(1023));
+  EXPECT_EQ("01.023", fmt::format("{:%S}", t3));
 }
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR