Support RFC-3339 parsing and formatting in Dates and SimpleDateFormats, re #60

Author: safris

src/main/java/org/libj/util/Dates.java

@@ -434,6 +434,23 @@ public static long dropMilliseconds(final long time) {
    * @throws ParseException If a parsing error has occurred.
    */
   public static long iso8601ToEpochMilli(final String iso8601) throws ParseException {
+    return iso8601ToEpochMilli(iso8601, 'T');
+  }
+
+  /**
+   * Converts a <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted date-time string to epoch millis.
+   *
+   * @param rfc3339 The <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted date-time string to convert.
+   * @return The millis representation of the <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted date-time
+   *         string.
+   * @throws NullPointerException If {@code rfc3339} is null.
+   * @throws ParseException If a parsing error has occurred.
+   */
+  public static long rfc3339ToEpochMilli(final String rfc3339) throws ParseException {
+    return iso8601ToEpochMilli(rfc3339, ' ');
+  }
+
+  private static long iso8601ToEpochMilli(final String iso8601, final char del) throws ParseException {
     final int len = iso8601.length();
     // The minimum length of a iso8601 dateTime is 14
     if (len < 14)
@@ -458,7 +475,7 @@ public static long iso8601ToEpochMilli(final String iso8601) throws ParseExcepti
     if (date == -1)
       throw new ParseException("Unparseable date: \"" + iso8601 + "\"", i - 2);
 
-    if (iso8601.charAt(i) == 'T')
+    if (iso8601.charAt(i) == del)
       ++i;
 
     if (len < i + 2)
@@ -571,8 +588,7 @@ else if (ch == '-')
     calendar.set(Calendar.HOUR_OF_DAY, hour);
     calendar.set(Calendar.MINUTE, minute);
     calendar.set(Calendar.SECOND, second);
-    if (millis > 0)
-      calendar.set(Calendar.MILLISECOND, millis);
+    calendar.set(Calendar.MILLISECOND, millis);
 
     if (offset != 0)
       calendar.add(Calendar.MINUTE, offset);
@@ -591,6 +607,31 @@ else if (ch == '-')
    */
   public static String epochMilliToIso8601(final long epochMilli) {
     final String iso8601 = SimpleDateFormats.ISO_8601.get().format(epochMilli);
+
+    if ((epochMilli / 1000) * 1000 == epochMilli)
+      return iso8601.substring(0, iso8601.length() - 4) + "Z";
+
+    if ((epochMilli / 100) * 100 == epochMilli)
+      return iso8601.substring(0, iso8601.length() - 2) + "Z";
+
+    if ((epochMilli / 10) * 10 == epochMilli)
+      return iso8601.substring(0, iso8601.length() - 1) + "Z";
+
+    return iso8601 + "Z";
+  }
+
+  /**
+   * Converts the provided epoch millis to a <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted date-time
+   * string representation.
+   *
+   * @param epochMilli The epoch millis to convert to <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted
+   *          date-time string representation.
+   * @return A <a href="https://datatracker.ietf.org/doc/html/rfc3339">RFC-3339</a> formatted date-time string representation of the
+   *         provided epoch millis.
+   */
+  public static String epochMilliToRfc3339(final long epochMilli) {
+    final String iso8601 = SimpleDateFormats.RFC_3339.get().format(epochMilli);
+
     if ((epochMilli / 1000) * 1000 == epochMilli)
       return iso8601.substring(0, iso8601.length() - 4) + "Z";
 

src/main/java/org/libj/util/SimpleDateFormats.java

@@ -129,8 +129,8 @@ public static final class IsoDate extends Date {
     private final ThreadLocal<SimpleDateFormat> format;
     private final int index;
 
-    private IsoDate(final long time, final TimeZone timeZone, final ThreadLocal<SimpleDateFormat> format, final int index) {
-      super(time);
+    private IsoDate(final long timeMs, final TimeZone timeZone, final ThreadLocal<SimpleDateFormat> format, final int index) {
+      super(timeMs);
       this.timeZone = timeZone;
       this.format = format;
       this.index = index;
@@ -174,15 +174,16 @@ public String toString() {
    * Returns a new {@link Date} object representing the {@code time} with the provided {@link SimpleDateFormat} that is to be used by
    * the {@link Date#toString()} of the returned date.
    *
-   * @param time The milliseconds since January 1, 1970, 00:00:00 GMT.
+   * @param timeMs The milliseconds since January 1, 1970, 00:00:00 GMT.
    * @param format The {@link SimpleDateFormat} that is to be used by the {@link Date#toString()} of the returned date.
    * @return A new {@link Date} object representing the {@code time}.
    */
-  public static Date newDate(final long time, final ThreadLocal<SimpleDateFormat> format) {
-    return new IsoDate(time, TimeZone.getDefault(), format, 0);
+  public static Date newDate(final long timeMs, final ThreadLocal<SimpleDateFormat> format) {
+    return new IsoDate(timeMs, TimeZone.getDefault(), format, 0);
   }
 
-  public static final ThreadLocal<SimpleDateFormat> ISO_8601 = SimpleDateFormats.newSimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
+  public static final ThreadLocal<SimpleDateFormat> ISO_8601 = SimpleDateFormats.newSimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", "yyyy-MM-dd'T'HH:mm:ss.SSS");
+  public static final ThreadLocal<SimpleDateFormat> RFC_3339 = SimpleDateFormats.newSimpleDateFormat("yyyy-MM-dd' 'HH:mm:ss", "yyyy-MM-dd' 'HH:mm:ss.SSS");
   public static final ThreadLocal<SimpleDateFormat> RFC_1123 = SimpleDateFormats.newSimpleDateFormat(Locale.US, "EEE, dd MMM yyyy HH:mm:ss Z", "EEE, dd MMM yyyy HH:mm:ss zz");
 
   public static ThreadLocal<SimpleDateFormat> newSimpleDateFormat(final Locale locale, final String ... patterns) {

src/test/java/org/libj/util/DatesTest.java

@@ -23,6 +23,7 @@
 import java.time.OffsetDateTime;
 import java.util.Random;
 import java.util.TimeZone;
+import java.util.function.ToLongFunction;
 
 import org.junit.After;
 import org.junit.Before;
@@ -53,74 +54,100 @@ public void testDatePart() {
         assertEquals("Iteration: " + i + " " + j, j, Dates.dropDatePart(Dates.MILLISECONDS_IN_DAY * i + j));
   }
 
-  private static String removeDashes(final String iso8601) {
-    final StringBuilder builder = new StringBuilder(iso8601);
-    builder.delete(7, 8);
-    builder.delete(4, 5);
-    return builder.toString();
+  private static String removeDashes(final String str) {
+    final StringBuilder b = new StringBuilder(str);
+    b.delete(7, 8);
+    b.delete(4, 5);
+    return b.toString();
   }
 
-  private static void assertEpochEquals(final long expected, final String iso8601) throws ParseException {
-    final long actual = Dates.iso8601ToEpochMilli(iso8601);
-    assertEquals(iso8601 + ": " + expected + " != " + expected + " ~ " + Math.abs(expected - actual), expected, actual, 1);
+  private static void assertEpochEquals(final ToLongFunction<String> fn, final long expected, final String str) throws ParseException {
+    final long actual = fn.applyAsLong(str);
+    assertEquals(str + ": " + expected + " != " + actual + " ~ " + Math.abs(expected - actual), expected, actual);
   }
 
-  private static void testTime2(final long expected, final String iso8601) throws ParseException {
-    assertEpochEquals(expected, iso8601);
-    assertEpochEquals(expected, removeDashes(iso8601));
-    assertEpochEquals(expected, iso8601.replace(":", ""));
-    assertEpochEquals(expected, iso8601.replace("T", ""));
-    assertEpochEquals(expected, removeDashes(iso8601).replace(":", ""));
-    assertEpochEquals(expected, removeDashes(iso8601).replace(":", "").replace("T", ""));
+  private static void testTime3(final ToLongFunction<String> fn, final long expected, final String str) throws ParseException {
+    assertEpochEquals(fn, expected, str);
+    assertEpochEquals(fn, expected, removeDashes(str));
+    assertEpochEquals(fn, expected, str.replace(":", ""));
+    assertEpochEquals(fn, expected, str.replace("T", ""));
+    assertEpochEquals(fn, expected, removeDashes(str).replace(":", ""));
+    assertEpochEquals(fn, expected, removeDashes(str).replace(":", "").replace("T", ""));
   }
 
-  private static void testTime(final long expected, String iso8601) throws ParseException {
-    testTime2(expected, iso8601);
-    iso8601 = iso8601.substring(0, iso8601.length() - 1);
+  private static void testTime2(final ToLongFunction<String> fn, final long expected, String str) throws ParseException {
+    testTime3(fn, expected, str);
+    str = str.substring(0, str.length() - 1);
 
     final int hourOffset = (int)(Math.random() * 18);
     final String offset = Strings.pad(String.valueOf(hourOffset), RIGHT, 2, '0');
-    testTime2(expected - hourOffset * 60 * 60 * 1000, iso8601 + "+" + offset);
-    testTime2(expected + hourOffset * 60 * 60 * 1000, iso8601 + "-" + offset);
+    testTime3(fn, expected - hourOffset * 60 * 60 * 1000, str + "+" + offset);
+    testTime3(fn, expected + hourOffset * 60 * 60 * 1000, str + "-" + offset);
 
     final int minOffset = (int)(Math.random() * 60);
     final String offset2 = offset + ":" + Strings.pad(String.valueOf(minOffset), RIGHT, 2, '0');
-    testTime2(expected - (hourOffset * 60 + minOffset) * 60 * 1000, iso8601 + "+" + offset2);
-    testTime2(expected + (hourOffset * 60 + minOffset) * 60 * 1000, iso8601 + "-" + offset2);
+    testTime3(fn, expected - (hourOffset * 60 + minOffset) * 60 * 1000, str + "+" + offset2);
+    testTime3(fn, expected + (hourOffset * 60 + minOffset) * 60 * 1000, str + "-" + offset2);
 
     final String offset3 = offset + Strings.pad(String.valueOf(minOffset), RIGHT, 2, '0');
-    testTime2(expected - (hourOffset * 60 + minOffset) * 60 * 1000, iso8601 + "+" + offset3);
-    testTime2(expected + (hourOffset * 60 + minOffset) * 60 * 1000, iso8601 + "-" + offset3);
+    testTime3(fn, expected - (hourOffset * 60 + minOffset) * 60 * 1000, str + "+" + offset3);
+    testTime3(fn, expected + (hourOffset * 60 + minOffset) * 60 * 1000, str + "-" + offset3);
   }
 
-  private static long usingTimeApi(final String iso8601) {
-    OffsetDateTime odt = OffsetDateTime.parse(iso8601);
+  private static void testTime1(final ToLongFunction<String> fn, long expected, String str, final char del) throws ParseException {
+    str = str.replace('T', del);
+    testTime2(fn, expected, str);
+
+    final int i = str.lastIndexOf('.') + 1;
+    final int end = str.length() - 1;
+
+    final String mils = str.substring(i, i + Math.min(3, end - i));
+    int millis = Integer.parseInt(mils);
+    millis *= mils.length() == 1 ? 100 : mils.length() == 2 ? 10 : 1;
+
+    str = str.substring(0, i - 1) + str.charAt(end);
+    expected -= millis;
+
+    testTime2(fn, expected, str);
+  }
+
+  private static long usingTimeApi(final String str) {
+    OffsetDateTime odt = OffsetDateTime.parse(str);
     Instant instant = odt.toInstant();
     return instant.getEpochSecond() * 1000;
   }
 
-  @Test
-  public void testIso8601ToEpochMilli() throws ParseException {
-    long timeMs = Dates.iso8601ToEpochMilli("2020-05-24T09:20:55.5Z");
-    testTime(timeMs, "2020-05-24T09:20:55.5Z");
-    testTime(timeMs, "2020-05-24T09:20:55.50Z");
-    testTime(timeMs, "2020-05-24T09:20:55.500Z");
-    testTime(timeMs, "2020-05-24T09:20:55.5002Z");
-    testTime(timeMs, "2020-05-24T09:20:55.50021Z");
-    testTime(timeMs, "2020-05-24T09:20:55.500210Z");
-    testTime(timeMs, "2020-05-24T09:20:55.5002101Z");
-    testTime(timeMs, "2020-05-24T09:20:55.50021012Z");
-    testTime(timeMs, "2020-05-24T09:20:55.500210123Z");
-    testTime(timeMs, "2020-05-24T09:20:55.5002101234Z");
-    testTime(timeMs, "2020-05-24T09:20:55.50021012345Z");
+  private static void testTime(final ToLongFunction<String> fn, final char del) throws ParseException {
+    long timeMs = fn.applyAsLong("2020-05-24" + del + "09:20:55.5Z");
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.5Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.50Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.500Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.5002Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.50021Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.500210Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.5002101Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.50021012Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.500210123Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.5002101234Z", del);
+    testTime1(fn, timeMs, "2020-05-24T09:20:55.50021012345Z", del);
 
     for (int i = 0; i < 100; ++i) { // [N]
       timeMs = System.currentTimeMillis();
-      final String iso8601 = Dates.epochMilliToIso8601(timeMs);
-      testTime(timeMs, iso8601);
+      final String str = Dates.epochMilliToIso8601(timeMs);
+      testTime1(fn, timeMs, str, del);
     }
   }
 
+  @Test
+  public void testRfc3339ToEpochMilli() throws ParseException {
+    testTime(Dates::rfc3339ToEpochMilli, ' ');
+  }
+
+  @Test
+  public void testIso8601ToEpochMilli() throws ParseException {
+    testTime(Dates::iso8601ToEpochMilli, 'T');
+  }
+
   @Test
   public void testDur() {
     for (int i = 0; i < 1000000; ++i) { // [N]