Minor performance improvements, more tests.

Author: Morten Haraldsen

src/main/java/com/ethlo/time/Duration.java

@@ -32,7 +32,7 @@
  */
 public class Duration implements Comparable<Duration>
 {
-    public static final Duration ZERO = new Duration(0,0);
+    public static final Duration ZERO = new Duration(0, 0);
 
     public static final int NANOS_PER_SECOND = 1_000_000_000;
     public static final long SECONDS_PER_MINUTE = 60;
@@ -315,4 +315,27 @@ public int compareTo(final Duration o)
                 .thenComparingInt(Duration::getNanos)
                 .compare(this, o);
     }
+
+    public Duration plusHours(final long hours)
+    {
+        return plusSeconds(Math.multiplyExact(hours, SECONDS_PER_HOUR));
+    }
+
+    public Duration plusMinutes(final long minutes)
+    {
+        return plusSeconds(Math.multiplyExact(minutes, SECONDS_PER_MINUTE));
+    }
+
+    public Duration plusSeconds(long seconds)
+    {
+        return new Duration(Math.addExact(this.seconds, seconds), nanos);
+    }
+
+    public Duration plusNanos(long nanos)
+    {
+        final long nanosTotal = Math.addExact(this.nanos, nanos);
+        final int nanosRemainder = Math.toIntExact(nanosTotal % NANOS_PER_SECOND);
+        final long extraSecs = nanosTotal / NANOS_PER_SECOND;
+        return new Duration(Math.addExact(seconds, extraSecs), nanosRemainder);
+    }
 }

src/main/java/com/ethlo/time/ItuDurationParser.java

@@ -21,9 +21,7 @@
  */
 
 import static com.ethlo.time.internal.fixed.ITUParser.DIGITS_IN_NANO;
-import static com.ethlo.time.internal.fixed.ITUParser.RADIX;
 import static com.ethlo.time.internal.fixed.ITUParser.sanityCheckInputParams;
-import static com.ethlo.time.internal.util.LimitedCharArrayIntegerUtil.DIGIT_9;
 import static com.ethlo.time.internal.util.LimitedCharArrayIntegerUtil.ZERO;
 
 import java.time.format.DateTimeParseException;
@@ -90,7 +88,8 @@ private static int readUntilNonDigit(final String chars, final int offset, final
         while (idx < len)
         {
             final char c = chars.charAt(idx);
-            if (c < ZERO || c > DIGIT_9)
+            int isDigit = (c - '0') >>> 31 | ('9' - c) >>> 31;
+            if (isDigit != 0)
             {
                 unit = c;
                 break;
@@ -105,7 +104,8 @@ private static int readUntilNonDigit(final String chars, final int offset, final
                     throw new DateTimeParseException("Numeric overflow while parsing value", chars, idx);
                 }
 
-                value = value * RADIX + digit;
+                value = (value << 3) + (value << 1) + (c - '0');
+                //value = value * RADIX + digit;
                 idx++;
             }
         }
@@ -135,11 +135,11 @@ private static class DurationPartsConsumer
         private boolean readingFractionalPart;
         private boolean afterT;
         private boolean pFound;
-        private boolean wFound;
-        private boolean dFound;
-        private boolean hFound;
-        private boolean mFound;
-        private boolean sFound;
+        private int wFound;
+        private int dFound;
+        private int hFound;
+        private int mFound;
+        private int sFound;
         private boolean dotFound;
         private boolean fractionsFound;
 
@@ -149,6 +149,11 @@ private DurationPartsConsumer(final int startOffset, boolean negative)
             this.negative = negative;
         }
 
+        private static DateTimeParseException error(String chars, int index)
+        {
+            return new DateTimeParseException("Units must be in order from largest to smallest", chars, index);
+        }
+
         public final void accept(final String chars, final int index, final int length, final char unit, final int value)
         {
             final int relIndex = index - startOffset;
@@ -195,7 +200,7 @@ public final void accept(final String chars, final int index, final int length,
 
                 case 'W':
                     assertNonFractional('W', chars, index);
-                    if (wFound)
+                    if (wFound > 0)
                     {
                         throw new DateTimeParseException("'W' (week) can only appear once", chars, index);
                     }
@@ -205,12 +210,12 @@ public final void accept(final String chars, final int index, final int length,
                         throw new DateTimeParseException("'W' (week) must appear before 'T' in the duration", chars, index);
                     }
                     seconds += value * 604800L; // 7 * 86400
-                    wFound = true;
+                    wFound = index;
                     break;
 
                 case 'D':
                     assertNonFractional('D', chars, index);
-                    if (dFound)
+                    if (dFound > 0)
                     {
                         throw new DateTimeParseException("'D' (days) can only appear once", chars, index);
                     }
@@ -219,12 +224,12 @@ public final void accept(final String chars, final int index, final int length,
                         throw new DateTimeParseException("'D' (days) must appear before 'T' in the duration", chars, index);
                     }
                     seconds += value * 86400L;
-                    dFound = true;
+                    dFound = index;
                     break;
 
                 case 'H':
                     assertNonFractional('H', chars, index);
-                    if (hFound)
+                    if (hFound > 0)
                     {
                         throw new DateTimeParseException("'H' (hours) can only appear once", chars, index);
                     }
@@ -233,12 +238,12 @@ public final void accept(final String chars, final int index, final int length,
                         throw new DateTimeParseException("'H' (hours) must appear after 'T' in the duration", chars, index);
                     }
                     seconds += value * 3600L;
-                    hFound = true;
+                    hFound = index;
                     break;
 
                 case 'M':
                     assertNonFractional('M', chars, index);
-                    if (mFound)
+                    if (mFound > 0)
                     {
                         throw new DateTimeParseException("'M' (minutes) can only appear once", chars, index);
                     }
@@ -247,19 +252,19 @@ public final void accept(final String chars, final int index, final int length,
                         throw new DateTimeParseException("'M' (minutes) must appear after 'T' in the duration", chars, index);
                     }
                     seconds += value * 60L;
-                    mFound = true;
+                    mFound = index;
                     break;
 
                 case 'S':
-                    if (sFound)
+                    if (sFound > 0)
                     {
                         throw new DateTimeParseException("'S' (seconds) can only appear once", chars, index);
                     }
                     if (!afterT)
                     {
                         throw new DateTimeParseException("'S' (seconds) must appear after 'T' in the duration", chars, index);
                     }
-                    sFound = true;
+                    sFound = index;
 
                     if (readingFractionalPart)
                     {
@@ -323,7 +328,7 @@ private void assertNonFractional(final char unit, final String chars, final int
 
         public void validate(String chars, int index)
         {
-            if (afterT && !hFound && !mFound && !sFound)
+            if (afterT && hFound == 0 && mFound == 0 && sFound == 0)
             {
                 throw new DateTimeParseException("Expected at least value and unit after the 'T'", chars, index);
             }
@@ -333,15 +338,52 @@ public void validate(String chars, int index)
                 throw new DateTimeParseException("Expected at least one fractional digit after the dot", chars, index);
             }
 
-            if (fractionsFound && !sFound)
+            if (fractionsFound && sFound == 0)
             {
                 throw new DateTimeParseException("Expected 'S' after fractional number", chars, index);
             }
 
-            if (!wFound && !dFound && !hFound && !mFound && !sFound)
+            if (wFound == 0 && dFound == 0 && hFound == 0 && mFound == 0 && sFound == 0)
             {
                 throw new DateTimeParseException("Expected at least one value and unit", chars, index);
             }
+
+            valdateUnitOrder(chars);
+        }
+
+        private void valdateUnitOrder(String chars)
+        {
+            int lastIndex = -1;
+
+            if (wFound > 0)
+            {
+                if (wFound < lastIndex) throw error(chars, wFound);
+                lastIndex = wFound;
+            }
+
+            if (dFound > 0)
+            {
+                if (dFound < lastIndex) throw error(chars, dFound);
+                lastIndex = dFound;
+            }
+
+            if (hFound > 0)
+            {
+                if (hFound < lastIndex) throw error(chars, hFound);
+                lastIndex = hFound;
+            }
+
+            if (mFound > 0)
+            {
+                if (mFound < lastIndex) throw error(chars, mFound);
+                lastIndex = mFound;
+            }
+
+            if (sFound > 0)
+            {
+                if (sFound < lastIndex) throw error(chars, sFound);
+                lastIndex = sFound;
+            }
         }
 
         public Duration getResult()

src/test/java/com/ethlo/time/ItuDurationParserTest.java

@@ -58,6 +58,31 @@ void testValidFullNotNormalizedToNormalizedNegative()
         assertThat(ItuDurationParser.parse("-P4W10DT28H122M1.123456S").normalized()).isEqualTo("-P5W4DT6H2M1.123456S");
     }
 
+    @Test
+    void testEmpty()
+    {
+        assertThrows(DateTimeParseException.class, () -> ItuDurationParser.parse(""));
+    }
+
+    @Test
+    void testNull()
+    {
+        assertThrows(NullPointerException.class, () -> ItuDurationParser.parse(null));
+    }
+
+    @Test
+    void testNothingAfterDot()
+    {
+        assertThrows(DateTimeParseException.class, () -> ItuDurationParser.parse("PT1."));
+    }
+
+    @Test
+    void testNoUnitAfterFractions()
+    {
+        assertThrows(DateTimeParseException.class, () -> ItuDurationParser.parse("PT1.5"));
+    }
+
+
     @Test
     void shouldParseZeroDuration()
     {
@@ -103,17 +128,15 @@ void shouldThrowDateTimeParseExceptionForInvalidUnits()
     @Test
     void shouldParseFractionalSecondsWithoutTrailingZeros()
     {
-        // Input: PT1.123000S (1 second, 123 milliseconds)
-        java.time.Duration duration = ItuDurationParser.parse("PT1.123000S").toDuration();
-        assertThat(duration).isEqualTo(java.time.Duration.ofSeconds(1).plusNanos(123000000));
+        final Duration duration = ItuDurationParser.parse("PT1.123000S");
+        assertThat(duration).isEqualTo(Duration.ofSeconds(1).plusNanos(123000000));
     }
 
     @Test
     void shouldHandleMultipleFractionalDigits()
     {
-        // Input: PT1.123456789S (1 second, 123456789 nanoseconds)
-        java.time.Duration duration = ItuDurationParser.parse("PT1.123456789S").toDuration();
-        assertThat(duration).isEqualTo(java.time.Duration.ofSeconds(1).plusNanos(123456789));
+        final Duration duration = ItuDurationParser.parse("PT1.123456789S");
+        assertThat(duration).isEqualTo(Duration.ofSeconds(1).plusNanos(123456789));
     }
 
     @Test
@@ -146,24 +169,21 @@ void shouldThrowDateTimeParseExceptionForMalformedDuration()
     @Test
     void shouldParseDurationWithWeeks()
     {
-        // Input: P1W2D (1 week, 2 days)
-        java.time.Duration duration = ItuDurationParser.parse("P1W2D").toDuration();
-        assertThat(duration).isEqualTo(java.time.Duration.ofDays(7 + 2)); // 7 days + 2 days
+        final Duration duration = ItuDurationParser.parse("P1W2D");
+        assertThat(duration).isEqualTo(Duration.ofDays(7 + 2));
     }
 
     @Test
     void shouldParseDurationWithTimeOnly()
     {
-        // Input: PT10H30M45S (10 hours, 30 minutes, 45 seconds)
-        java.time.Duration duration = ItuDurationParser.parse("PT10H30M45S").toDuration();
-
-        assertThat(duration).isEqualTo(java.time.Duration.ofHours(10).plusMinutes(30).plusSeconds(45));
+        final Duration duration = ItuDurationParser.parse("PT10H30M45S");
+        assertThat(duration).isEqualTo(Duration.ofHours(10).plusMinutes(30).plusSeconds(45));
     }
 
     @Test
     void parse0DDurationAsZero()
     {
-        java.time.Duration duration = ItuDurationParser.parse("P0D").toDuration();
-        assertThat(duration).isEqualTo(java.time.Duration.ZERO);
+        final Duration duration = ItuDurationParser.parse("P0D");
+        assertThat(duration).isEqualTo(Duration.ZERO);
     }
 }