RFR:JDK-8141452:Convert between TimeUnit and ChronoUnit

[Roger Riggs]

Hi Martin,

Where did IllegalMonitorStateException creep in from?

Should I update the CCC I started or will you start fresh?

Otherwise, ok.

Roger


On 1/29/2016 2:12 PM, Martin Buchholz wrote:
> Here is a proposed alternative patch (against jsr166 CVS).
> Code is reworded and reformatted.
> Tests are junit-ified.
> Round-trip tests are added.
> toChronoUnit no longer throws IAE, because it cannot (and we commit to
> having ChronoUnit be a superset of TimeUnit, in perpetuity;
> toChronoUnit will forever be an injective function).
>
> Index: src/main/java/util/concurrent/TimeUnit.java
> ===================================================================
> RCS file: /export/home/jsr166/jsr166/jsr166/src/main/java/util/concurrent/TimeUnit.java,v
> retrieving revision 1.47
> diff -u -r1.47 TimeUnit.java
> --- src/main/java/util/concurrent/TimeUnit.java 20 Sep 2015 17:03:23 -0000 1.47
> +++ src/main/java/util/concurrent/TimeUnit.java 29 Jan 2016 19:05:01 -0000
> @@ -6,6 +6,9 @@
>
>   package java.util.concurrent;
>
> +import java.time.temporal.ChronoUnit;
> +import java.util.Objects;
> +
>   /**
>    * A {@code TimeUnit} represents time durations at a given unit of
>    * granularity and provides utility methods to convert across units,
> @@ -361,4 +364,48 @@
>           }
>       }
>
> +    /**
> +     * Converts this {@code TimeUnit} to the equivalent {@code ChronoUnit}.
> +     *
> +     * @return the converted equivalent ChronoUnit
> +     * @since 9
> +     */
> +    public ChronoUnit toChronoUnit() {
> +        switch (this) {
> +        case NANOSECONDS:  return ChronoUnit.NANOS;
> +        case MICROSECONDS: return ChronoUnit.MICROS;
> +        case MILLISECONDS: return ChronoUnit.MILLIS;
> +        case SECONDS:      return ChronoUnit.SECONDS;
> +        case MINUTES:      return ChronoUnit.MINUTES;
> +        case HOURS:        return ChronoUnit.HOURS;
> +        case DAYS:         return ChronoUnit.DAYS;
> +        default: throw new AssertionError();
> +        }
> +    }
> +
> +    /**
> +     * Converts a {@code ChronoUnit} to the equivalent {@code TimeUnit}.
> +     *
> +     * @param chronoUnit the ChronoUnit to convert
> +     * @return the converted equivalent TimeUnit
> +     * @throws IllegalArgumentException if {@code chronoUnit} has no
> +     *         equivalent TimeUnit
> +     * @throws NullPointerException if {@code chronoUnit} is null
> +     * @since 9
> +     */
> +    public static TimeUnit of(ChronoUnit chronoUnit) {
> +        switch (Objects.requireNonNull(chronoUnit, "chronoUnit")) {
> +        case NANOS:   return TimeUnit.NANOSECONDS;
> +        case MICROS:  return TimeUnit.MICROSECONDS;
> +        case MILLIS:  return TimeUnit.MILLISECONDS;
> +        case SECONDS: return TimeUnit.SECONDS;
> +        case MINUTES: return TimeUnit.MINUTES;
> +        case HOURS:   return TimeUnit.HOURS;
> +        case DAYS:    return TimeUnit.DAYS;
> +        default:
> +            throw new IllegalArgumentException(
> +                "No TimeUnit equivalent for " + chronoUnit);
> +        }
> +    }
> +
>   }
> Index: src/test/tck/TimeUnitTest.java
> ===================================================================
> RCS file: /export/home/jsr166/jsr166/jsr166/src/test/tck/TimeUnitTest.java,v
> retrieving revision 1.25
> diff -u -r1.25 TimeUnitTest.java
> --- src/test/tck/TimeUnitTest.java 25 Apr 2015 04:55:31 -0000 1.25
> +++ src/test/tck/TimeUnitTest.java 29 Jan 2016 19:05:02 -0000
> @@ -14,6 +14,7 @@
>   import static java.util.concurrent.TimeUnit.NANOSECONDS;
>   import static java.util.concurrent.TimeUnit.SECONDS;
>
> +import java.time.temporal.ChronoUnit;
>   import java.util.concurrent.CountDownLatch;
>   import java.util.concurrent.TimeUnit;
>
> @@ -433,4 +434,49 @@
>           assertSame(x, serialClone(x));
>       }
>
> +    /**
> +     * tests for toChronoUnit.
> +     */
> +    public void testToChronoUnit() throws Exception {
> +        assertSame(ChronoUnit.NANOS,   NANOSECONDS.toChronoUnit());
> +        assertSame(ChronoUnit.MICROS,  MICROSECONDS.toChronoUnit());
> +        assertSame(ChronoUnit.MILLIS,  MILLISECONDS.toChronoUnit());
> +        assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
> +        assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
> +        assertSame(ChronoUnit.HOURS,   HOURS.toChronoUnit());
> +        assertSame(ChronoUnit.DAYS,    DAYS.toChronoUnit());
> +
> +        // Every TimeUnit has a defined ChronoUnit equivalent
> +        for (TimeUnit x : TimeUnit.values())
> +            assertSame(x, TimeUnit.of(x.toChronoUnit()));
> +    }
> +
> +    /**
> +     * tests for TimeUnit.of(ChronoUnit).
> +     */
> +    public void testTimeUnitOf() throws Exception {
> +        assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
> +        assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
> +        assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
> +        assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
> +        assertSame(MINUTES,      TimeUnit.of(ChronoUnit.MINUTES));
> +        assertSame(HOURS,        TimeUnit.of(ChronoUnit.HOURS));
> +        assertSame(DAYS,         TimeUnit.of(ChronoUnit.DAYS));
> +
> +        assertThrows(NullPointerException.class,
> +                     () -> TimeUnit.of((ChronoUnit)null));
> +
> +        // ChronoUnits either round trip to their TimeUnit
> +        // equivalents, or throw IllegalMonitorStateException.
> +        for (ChronoUnit cu : ChronoUnit.values()) {
> +            final TimeUnit tu;
> +            try {
> +                tu = TimeUnit.of(cu);
> +            } catch (IllegalArgumentException acceptable) {
> +                continue;
> +            }
> +            assertSame(cu, tu.toChronoUnit());
> +        }
> +    }
> +
>   }