Avoid String(format:)

This is part of an experiment to try using SwiftProtobuf
in constrained environments where Foundation is unavailable.

Author: tbkka

Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift

@@ -94,20 +94,30 @@ private func parseDuration(text: String) throws -> (Int64, Int32) {
   throw JSONDecodingError.malformedDuration
 }
 
+private func formatZeroPaddedInt(_ value: Int32, digits: Int) -> String {
+  let s = String(value)
+  if s.count >= digits {
+    return s
+  } else {
+    let pad = String(repeating: "0", count: digits - s.count)
+    return pad + s
+  }
+}
+
 private func formatDuration(seconds: Int64, nanos: Int32) -> String? {
   let (seconds, nanos) = normalizeForDuration(seconds: seconds, nanos: nanos)
   guard seconds >= minDurationSeconds && seconds <= maxDurationSeconds else {
     return nil
   }
 
   if nanos == 0 {
-    return String(format: "%llds", seconds)
+    return String(seconds) + "s"
   } else if nanos % 1000000 == 0 {
-    return String(format: "%lld.%03ds", seconds, abs(nanos) / 1000000)
+    return "\(seconds).\(formatZeroPaddedInt(abs(nanos) / 1000000, digits: 3))s"
   } else if nanos % 1000 == 0 {
-    return String(format: "%lld.%06ds", seconds, abs(nanos) / 1000)
+    return "\(seconds).\(formatZeroPaddedInt(abs(nanos) / 1000, digits: 6))s"
   } else {
-    return String(format: "%lld.%09ds", seconds, abs(nanos))
+    return "\(seconds).\(formatZeroPaddedInt(abs(nanos), digits: 9))s"
   }
 }
 

Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift

@@ -182,6 +182,37 @@ private func parseTimestamp(s: String) throws -> (Int64, Int32) {
   return (seconds, nanos)
 }
 
+private func formatZeroPaddedInt(_ value: Int32, digits: Int) -> String {
+  let s = String(value)
+  if s.count >= digits {
+    return s
+  } else {
+    let pad = String(repeating: "0", count: digits - s.count)
+    return pad + s
+  }
+}
+
+private func twoDigit(_ value: Int32) -> String {
+  return formatZeroPaddedInt(value, digits: 2)
+}
+
+private func threeDigit(_ value: Int32) -> String {
+  return formatZeroPaddedInt(value, digits: 3)
+}
+
+private func fourDigit(_ value: Int32) -> String {
+  return formatZeroPaddedInt(value, digits: 4)
+}
+
+private func sixDigit(_ value: Int32) -> String {
+  return formatZeroPaddedInt(value, digits: 6)
+}
+
+private func nineDigit(_ value: Int32) -> String {
+  return formatZeroPaddedInt(value, digits: 9)
+}
+
+
 private func formatTimestamp(seconds: Int64, nanos: Int32) -> String? {
   let (seconds, nanos) = normalizeForTimestamp(seconds: seconds, nanos: nanos)
   guard seconds >= minTimestampSeconds && seconds <= maxTimestampSeconds else {
@@ -191,18 +222,17 @@ private func formatTimestamp(seconds: Int64, nanos: Int32) -> String? {
   let (hh, mm, ss) = timeOfDayFromSecondsSince1970(seconds: seconds)
   let (YY, MM, DD) = gregorianDateFromSecondsSince1970(seconds: seconds)
 
+  let dateString = "\(fourDigit(YY))-\(twoDigit(MM))-\(twoDigit(DD))"
+  let timeString = "\(twoDigit(hh)):\(twoDigit(mm)):\(twoDigit(ss))"
+
   if nanos == 0 {
-    return String(format: "%04d-%02d-%02dT%02d:%02d:%02dZ",
-                  YY, MM, DD, hh, mm, ss)
+    return "\(dateString)T\(timeString)Z"
   } else if nanos % 1000000 == 0 {
-    return String(format: "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
-                  YY, MM, DD, hh, mm, ss, nanos / 1000000)
+    return "\(dateString)T\(timeString).\(threeDigit(nanos / 1000000))Z"
   } else if nanos % 1000 == 0 {
-    return String(format: "%04d-%02d-%02dT%02d:%02d:%02d.%06dZ",
-                  YY, MM, DD, hh, mm, ss, nanos / 1000)
+    return "\(dateString)T\(timeString).\(sixDigit(nanos / 1000))Z"
   } else {
-    return String(format: "%04d-%02d-%02dT%02d:%02d:%02d.%09dZ",
-                  YY, MM, DD, hh, mm, ss, nanos)
+    return "\(dateString)T\(timeString).\(nineDigit(nanos))Z"
   }
 }