@@ -112,13 +112,23 @@ * obtain the time from a central time server across the network. Obviously, in this case the * lookup could fail, and so the method is permitted to throw an exception. *
- * The returned instants from {@code Clock} work on a time-scale that ignores leap seconds. - * If the implementation wraps a source that provides leap second information, then a mechanism - * should be used to "smooth" the leap second, such as UTC-SLS. + * The returned instants from {@code Clock} work on a time-scale that ignores leap seconds, + * as described in {@link Instant}. If the implementation wraps a source that provides leap + * second information, then a mechanism should be used to "smooth" the leap second. + * The Java Time-Scale mandates the use of UTC-SLS, however clock implementations may choose + * how accurate they are with the time-scale so long as they document how they work. + * Implementations are therefore not required to actually perform the UTC-SLS slew or to + * otherwise be aware of leap seconds. *
* Implementations should implement {@code Serializable} wherever possible and must * document whether or not they do support serialization. * + * @implNote + * The clock implementation provided here is based on {@link System#currentTimeMillis()}. + * That method provides little to no guarantee about the accuracy of the clock. + * Applications requiring a more accurate clock must implement this abstract class + * themselves using a different external clock, such as an NTP server. + * * @since 1.8 */ public abstract class Clock { @@ -370,7 +380,7 @@ /** * Gets the current millisecond instant of the clock. *
- * This returns the millisecond-based instant, measured from 1970-01-01T00:00 UTC. + * This returns the millisecond-based instant, measured from 1970-01-01T00:00Z (UTC). * This is equivalent to the definition of {@link System#currentTimeMillis()}. *
* Most applications should avoid this method and use {@link Instant} to represent @@ -381,7 +391,7 @@ * The default implementation currently calls {@link #instant}. * * @return the current millisecond instant from this clock, measured from - * the Java epoch of 1970-01-01T00:00 UTC, not null + * the Java epoch of 1970-01-01T00:00Z (UTC), not null * @throws DateTimeException if the instant cannot be obtained, not thrown by most implementations */ public long millis() { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/DateTimeException.java --- a/jdk/src/share/classes/java/time/DateTimeException.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/DateTimeException.java Wed May 15 07:48:57 2013 -0700 @@ -67,7 +67,7 @@ * This exception is used to indicate problems with creating, querying * and manipulating date-time objects. * - *
* Given the complexity of accurate timekeeping described above, this Java API defines - * its own time-scale with a simplification. The Java time-scale is defined as follows: + * its own time-scale, the Java Time-Scale. + *
+ * The Java Time-Scale divides each calendar day into exactly 86400 + * subdivisions, known as seconds. These seconds may differ from the + * SI second. It closely matches the de facto international civil time + * scale, the definition of which changes from time to time. + *
+ * The Java Time-Scale has slightly different definitions for different + * segments of the time-line, each based on the consensus international + * time scale that is used as the basis for civil time. Whenever the + * internationally-agreed time scale is modified or replaced, a new + * segment of the Java Time-Scale must be defined for it. Each segment + * must meet these requirements: *
- * Agreed international civil time is the base time-scale agreed by international convention, - * which in 2012 is UTC (with leap-seconds). - *
- * In 2012, the definition of the Java time-scale is the same as UTC for all days except - * those where a leap-second occurs. On days where a leap-second does occur, the time-scale - * effectively eliminates the leap-second, maintaining the fiction of 86400 seconds in the day. - * The approved well-defined algorithm to eliminate leap-seconds is specified as - * UTC-SLS. + * There are currently, as of 2013, two segments in the Java time-scale. *
- * UTC-SLS is a simple algorithm that smoothes the leap-second over the last 1000 seconds of - * the day, making each of the last 1000 seconds 1/1000th longer or shorter than an SI second. - * Implementations built on an accurate leap-second aware time source should use UTC-SLS. - * Use of a different algorithm risks confusion and misinterpretation of instants around a - * leap-second and is discouraged. + * For the segment from 1972-11-03 (exact boundary discussed below) until + * further notice, the consensus international time scale is UTC (with + * leap seconds). In this segment, the Java Time-Scale is identical to + * UTC-SLS. + * This is identical to UTC on days that do not have a leap second. + * On days that do have a leap second, the leap second is spread equally + * over the last 1000 seconds of the day, maintaining the appearance of + * exactly 86400 seconds per day. *
- * The main benefit of always dividing the day into 86400 subdivisions is that it matches the - * expectations of most users of the API. The alternative is to force every user to understand - * what a leap second is and to force them to have special logic to handle them. - * Most applications do not have access to a clock that is accurate enough to record leap-seconds. - * Most applications also do not have a problem with a second being a very small amount longer or - * shorter than a real SI second during a leap-second. + * For the segment prior to 1972-11-03, extending back arbitrarily far, + * the consensus international time scale is defined to be UT1, applied + * proleptically, which is equivalent to the (mean) solar time on the + * prime meridian (Greenwich). In this segment, the Java Time-Scale is + * identical to the consensus international time scale. The exact + * boundary between the two segments is the instant where UT1 = UTC + * between 1972-11-03T00:00 and 1972-11-04T12:00. *
- * One final problem is the definition of the agreed international civil time before the - * introduction of modern UTC in 1972. This includes the Java epoch of {@code 1970-01-01}. - * It is intended that instants before 1972 be interpreted based on the solar day divided - * into 86400 subdivisions, as per the principles of UT1. + * Implementations of the Java time-scale using the JSR-310 API are not + * required to provide any clock that is sub-second accurate, or that + * progresses monotonically or smoothly. Implementations are therefore + * not required to actually perform the UTC-SLS slew or to otherwise be + * aware of leap seconds. JSR-310 does, however, require that + * implementations must document the approach they use when defining a + * clock representing the current instant. + * See {@link Clock} for details on the available clocks. *
* The Java time-scale is used for all date-time classes. * This includes {@code Instant}, {@code LocalDate}, {@code LocalTime}, {@code OffsetDateTime}, * {@code ZonedDateTime} and {@code Duration}. * - *
- * This calculates the period between two instants in terms of a single unit. + * This calculates the amount of time between two {@code Instant} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified instant. * The result will be negative if the end is before the start. * The calculation returns a whole number, representing the number of * complete units between the two instants. * The {@code Temporal} passed to this method must be an {@code Instant}. - * For example, the period in days between two dates can be calculated + * For example, the amount in days between two dates can be calculated * using {@code startInstant.periodUntil(endInstant, SECONDS)}. *
* There are two equivalent ways of using this method. @@ -1064,10 +1077,10 @@ *
* This instance is immutable and unaffected by this method call. * - * @param endInstant the end date, which must be a {@code LocalDate}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date and the end date - * @throws DateTimeException if the period cannot be calculated + * @param endInstant the end date, which must be an {@code Instant}, not null + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this instant and the end instant + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1075,7 +1088,7 @@ public long periodUntil(Temporal endInstant, TemporalUnit unit) { if (endInstant instanceof Instant == false) { Objects.requireNonNull(endInstant, "endInstant"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } Instant end = (Instant) endInstant; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/LocalDate.java --- a/jdk/src/share/classes/java/time/LocalDate.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/LocalDate.java Wed May 15 07:48:57 2013 -0700 @@ -121,7 +121,7 @@ * However, any application that makes use of historical dates, and requires them * to be accurate will find the ISO-8601 approach unsuitable. * - *
- * This calculates the period between two dates in terms of a single unit. + * This calculates the amount of time between two {@code LocalDate} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a {@code LocalDate}. - * For example, the period in days between two dates can be calculated + * For example, the amount in days between two dates can be calculated * using {@code startDate.periodUntil(endDate, DAYS)}. *
* The calculation returns a whole number, representing the number of * complete units between the two dates. - * For example, the period in months between 2012-06-15 and 2012-08-14 + * For example, the amount in months between 2012-06-15 and 2012-08-14 * will only be one month as it is one day short of two months. *
* There are two equivalent ways of using this method. @@ -1527,9 +1527,9 @@ * This instance is immutable and unaffected by this method call. * * @param endDate the end date, which must be a {@code LocalDate}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date and the end date - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this date and the end date + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1538,7 +1538,7 @@ Objects.requireNonNull(unit, "unit"); if (endDate instanceof LocalDate == false) { Objects.requireNonNull(endDate, "endDate"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } LocalDate end = (LocalDate) endDate; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/LocalDateTime.java --- a/jdk/src/share/classes/java/time/LocalDateTime.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/LocalDateTime.java Wed May 15 07:48:57 2013 -0700 @@ -119,7 +119,7 @@ * However, any application that makes use of historical dates, and requires them * to be accurate will find the ISO-8601 approach unsuitable. * - *
- * This calculates the period between two date-times in terms of a single unit. + * This calculates the amount of time between two {@code LocalDateTime} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date-time. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a {@code LocalDateTime}. - * For example, the period in days between two date-times can be calculated + * For example, the amount in days between two date-times can be calculated * using {@code startDateTime.periodUntil(endDateTime, DAYS)}. *
* The calculation returns a whole number, representing the number of * complete units between the two date-times. - * For example, the period in months between 2012-06-15T00:00 and 2012-08-14T23:59 + * For example, the amount in months between 2012-06-15T00:00 and 2012-08-14T23:59 * will only be one month as it is one minute short of two months. *
* There are two equivalent ways of using this method. @@ -1602,9 +1602,9 @@ * This instance is immutable and unaffected by this method call. * * @param endDateTime the end date-time, which must be a {@code LocalDateTime}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date-time and the end date-time - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this date-time and the end date-time + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1612,7 +1612,7 @@ public long periodUntil(Temporal endDateTime, TemporalUnit unit) { if (endDateTime instanceof LocalDateTime == false) { Objects.requireNonNull(endDateTime, "endDateTime"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } LocalDateTime end = (LocalDateTime) endDateTime; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/LocalTime.java --- a/jdk/src/share/classes/java/time/LocalTime.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/LocalTime.java Wed May 15 07:48:57 2013 -0700 @@ -109,7 +109,7 @@ * in most of the world. This API assumes that all calendar systems use the same * representation, this class, for time-of-day. * - *
* All other {@code ChronoUnit} instances will throw an {@code UnsupportedTemporalTypeException}. @@ -1007,7 +1004,6 @@ case MINUTES: return plusMinutes(amountToAdd); case HOURS: return plusHours(amountToAdd); case HALF_DAYS: return plusHours((amountToAdd % 2) * 12); - case DAYS: return this; } throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit.getName()); } @@ -1291,19 +1287,19 @@ } /** - * Calculates the period between this time and another time in - * terms of the specified unit. + * Calculates the amount of time until another time in terms of the specified unit. *
- * This calculates the period between two times in terms of a single unit. + * This calculates the amount of time between two {@code LocalTime} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified time. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a {@code LocalTime}. - * For example, the period in hours between two times can be calculated + * For example, the amount in hours between two times can be calculated * using {@code startTime.periodUntil(endTime, HOURS)}. *
* The calculation returns a whole number, representing the number of * complete units between the two times. - * For example, the period in hours between 11:30 and 13:29 will only + * For example, the amount in hours between 11:30 and 13:29 will only * be one hour as it is one minute short of two hours. *
* There are two equivalent ways of using this method. @@ -1329,9 +1325,9 @@ * This instance is immutable and unaffected by this method call. * * @param endTime the end time, which must be a {@code LocalTime}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this time and the end time - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this time and the end time + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1339,7 +1335,7 @@ public long periodUntil(Temporal endTime, TemporalUnit unit) { if (endTime instanceof LocalTime == false) { Objects.requireNonNull(endTime, "endTime"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } LocalTime end = (LocalTime) endTime; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/Month.java --- a/jdk/src/share/classes/java/time/Month.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/Month.java Wed May 15 07:48:57 2013 -0700 @@ -97,7 +97,7 @@ * As such, this enum may be used by any calendar system that has the month-of-year * concept defined exactly equivalent to the ISO-8601 calendar system. * - *
- * This calculates the period between two date-times in terms of a single unit. + * This calculates the amount of time between two {@code OffsetDateTime} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date-time. * The result will be negative if the end is before the start. * For example, the period in days between two date-times can be calculated @@ -1564,9 +1564,9 @@ * This instance is immutable and unaffected by this method call. * * @param endDateTime the end date-time, which must be an {@code OffsetDateTime}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date-time and the end date-time - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this date-time and the end date-time + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1574,7 +1574,7 @@ public long periodUntil(Temporal endDateTime, TemporalUnit unit) { if (endDateTime instanceof OffsetDateTime == false) { Objects.requireNonNull(endDateTime, "endDateTime"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } if (unit instanceof ChronoUnit) { OffsetDateTime end = (OffsetDateTime) endDateTime; diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/OffsetTime.java --- a/jdk/src/share/classes/java/time/OffsetTime.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/OffsetTime.java Wed May 15 07:48:57 2013 -0700 @@ -102,7 +102,7 @@ * For example, the value "13:45.30.123456789+02:00" can be stored * in an {@code OffsetTime}. * - *
- * This calculates the period between two times in terms of a single unit. + * This calculates the amount of time between two {@code OffsetTime} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified time. * The result will be negative if the end is before the start. * For example, the period in hours between two times can be calculated @@ -1118,9 +1118,9 @@ * This instance is immutable and unaffected by this method call. * * @param endTime the end time, which must be an {@code OffsetTime}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this time and the end time - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this time and the end time + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -1128,7 +1128,7 @@ public long periodUntil(Temporal endTime, TemporalUnit unit) { if (endTime instanceof OffsetTime == false) { Objects.requireNonNull(endTime, "endTime"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } if (unit instanceof ChronoUnit) { OffsetTime end = (OffsetTime) endTime; diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/Period.java --- a/jdk/src/share/classes/java/time/Period.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/Period.java Wed May 15 07:48:57 2013 -0700 @@ -119,7 +119,7 @@ * The months and years fields may be {@linkplain #normalized() normalized}. * The normalization assumes a 12 month year, so is not appropriate for all calendar systems. * - *
- * This calculates the period between two years in terms of a single unit. + * This calculates the amount of time between two {@code Year} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified year. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a {@code Year}. @@ -851,9 +851,9 @@ * This instance is immutable and unaffected by this method call. * * @param endYear the end year, which must be a {@code Year}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this year and the end year - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this year and the end year + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -861,7 +861,7 @@ public long periodUntil(Temporal endYear, TemporalUnit unit) { if (endYear instanceof Year == false) { Objects.requireNonNull(endYear, "endYear"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } Year end = (Year) endYear; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/YearMonth.java --- a/jdk/src/share/classes/java/time/YearMonth.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/YearMonth.java Wed May 15 07:48:57 2013 -0700 @@ -110,7 +110,7 @@ * However, any application that makes use of historical dates, and requires them * to be accurate will find the ISO-8601 approach unsuitable. * - *
- * This calculates the period between two year-months in terms of a single unit. + * This calculates the amount of time between two {@code YearMonth} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified year-month. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a {@code YearMonth}. @@ -982,9 +982,9 @@ * This instance is immutable and unaffected by this method call. * * @param endYearMonth the end year-month, which must be a {@code YearMonth}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this year-month and the end year-month - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this year-month and the end year-month + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -992,7 +992,7 @@ public long periodUntil(Temporal endYearMonth, TemporalUnit unit) { if (endYearMonth instanceof YearMonth == false) { Objects.requireNonNull(endYearMonth, "endYearMonth"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } YearMonth end = (YearMonth) endYearMonth; if (unit instanceof ChronoUnit) { diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/ZoneId.java --- a/jdk/src/share/classes/java/time/ZoneId.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/ZoneId.java Wed May 15 07:48:57 2013 -0700 @@ -157,7 +157,7 @@ * This approach is designed to allow a {@link ZonedDateTime} to be loaded and * queried, but not modified, on a Java Runtime with incomplete time-zone information. * - *
- * This calculates the period between two date-times in terms of a single unit. + * This calculates the amount of time between two {@code ZonedDateTime} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date-time. * The result will be negative if the end is before the start. * For example, the period in days between two date-times can be calculated @@ -2040,9 +2040,9 @@ * This instance is immutable and unaffected by this method call. * * @param endDateTime the end date-time, which must be a {@code ZonedDateTime}, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date-time and the end date-time - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this date-time and the end date-time + * @throws DateTimeException if the amount cannot be calculated * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ @@ -2050,7 +2050,7 @@ public long periodUntil(Temporal endDateTime, TemporalUnit unit) { if (endDateTime instanceof ZonedDateTime == false) { Objects.requireNonNull(endDateTime, "endDateTime"); - throw new DateTimeException("Unable to calculate period between objects of two different types"); + throw new DateTimeException("Unable to calculate amount as objects are of two different types"); } if (unit instanceof ChronoUnit) { ZonedDateTime end = (ZonedDateTime) endDateTime; diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/chrono/ChronoDateImpl.java --- a/jdk/src/share/classes/java/time/chrono/ChronoDateImpl.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/chrono/ChronoDateImpl.java Wed May 15 07:48:57 2013 -0700 @@ -130,7 +130,7 @@ * The subclass must function according to the {@code Chronology} class description and must provide its * {@link java.time.chrono.Chronology#getId() chronlogy ID} and {@link Chronology#getCalendarType() calendar type}.
* - *- * This calculates the period between two dates in terms of a single unit. + * This calculates the amount of time between two {@code ChronoLocalDate} + * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method must be a * {@code ChronoLocalDate} in the same chronology. * The calculation returns a whole number, representing the number of * complete units between the two dates. - * For example, the period in days between two dates can be calculated + * For example, the amount in days between two dates can be calculated * using {@code startDate.periodUntil(endDate, DAYS)}. *
* There are two equivalent ways of using this method. @@ -548,9 +549,9 @@ * * @param endDate the end date, which must be a {@code ChronoLocalDate} * in the same chronology, not null - * @param unit the unit to measure the period in, not null - * @return the amount of the period between this date and the end date - * @throws DateTimeException if the period cannot be calculated + * @param unit the unit to measure the amount in, not null + * @return the amount of time between this date and the end date + * @throws DateTimeException if the amount cannot be calculated * @throws ArithmeticException if numeric overflow occurs */ @Override // override for Javadoc diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/chrono/ChronoLocalDateTime.java --- a/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTime.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTime.java Wed May 15 07:48:57 2013 -0700 @@ -106,7 +106,7 @@ * Ensure that the discussion in {@code ChronoLocalDate} has been read and understood * before using this interface. * - *
* The {@code Locale} class also supports an extension mechanism that * can be used to identify a calendar system. The mechanism is a form - * of key-value pairs, where the calendar system has the key "ca" - * and an optional variant key "cv". + * of key-value pairs, where the calendar system has the key "ca". * For example, the locale "en-JP-u-ca-japanese" represents the English * language as used in Japan with the Japanese calendar system. *
* This method finds the desired calendar system by in a manner equivalent * to passing "ca" to {@link Locale#getUnicodeLocaleType(String)}. * If the "ca" key is not present, then {@code IsoChronology} is returned. - * The variant, if present, is appended to the "ca" value separated by "-" - * and the concatenated value is used to find the calendar system by type. *
* Note that the behavior of this method differs from the older * {@link java.util.Calendar#getInstance(Locale)} method. @@ -374,10 +371,6 @@ if (type == null || "iso".equals(type) || "iso8601".equals(type)) { return IsoChronology.INSTANCE; } - String variant = locale.getUnicodeLocaleType("cv"); - if (variant != null && !variant.isEmpty()) { - type = type + '-' + variant; - } // Not pre-defined; lookup by the type do { Chronology chrono = CHRONOS_BY_TYPE.get(type); @@ -563,7 +556,7 @@ * and the variant, if applicable, is appended separated by "-". * The calendar type is used to lookup the {@code Chronology} using {@link #of(String)}. * - * @return the calendar system type, null if the calendar is not defined + * @return the calendar system type, null if the calendar is not defined by CLDR/LDML * @see #getId() */ public abstract String getCalendarType(); diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/chrono/Era.java --- a/jdk/src/share/classes/java/time/chrono/Era.java Wed May 15 15:01:59 2013 +0100 +++ b/jdk/src/share/classes/java/time/chrono/Era.java Wed May 15 07:48:57 2013 -0700 @@ -93,7 +93,7 @@ *
* Instances of {@code Era} may be compared using the {@code ==} operator. * - *
* - *
* - *
* - *
- * A significant part of dealing with dates and times is the localization. - * This class acts as a central point for accessing the information. - * - *
- * This uses standard ASCII characters for zero, positive, negative and a dot for the decimal point.
- */
- public static final DateTimeFormatSymbols STANDARD = new DateTimeFormatSymbols('0', '+', '-', '.');
- /**
- * The cache of symbols instances.
- */
- private static final ConcurrentMap
- * The locale 'en_US' will always be present.
- *
- * @return an array of locales for which localization is supported
- */
- public static Locale[] getAvailableLocales() {
- return DecimalFormatSymbols.getAvailableLocales();
- }
-
- /**
- * Obtains symbols for the default
- * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
- *
- * This method provides access to locale sensitive symbols.
- *
- * This is equivalent to calling
- * {@link #of(Locale)
- * of(Locale.getDefault(Locale.Category.FORMAT))}.
- *
- * @see java.util.Locale.Category#FORMAT
- * @return the info, not null
- */
- public static DateTimeFormatSymbols ofDefaultLocale() {
- return of(Locale.getDefault(Locale.Category.FORMAT));
- }
-
- /**
- * Obtains symbols for the specified locale.
- *
- * This method provides access to locale sensitive symbols.
- *
- * @param locale the locale, not null
- * @return the info, not null
- */
- public static DateTimeFormatSymbols of(Locale locale) {
- Objects.requireNonNull(locale, "locale");
- DateTimeFormatSymbols info = CACHE.get(locale);
- if (info == null) {
- info = create(locale);
- CACHE.putIfAbsent(locale, info);
- info = CACHE.get(locale);
- }
- return info;
- }
-
- private static DateTimeFormatSymbols create(Locale locale) {
- DecimalFormatSymbols oldSymbols = DecimalFormatSymbols.getInstance(locale);
- char zeroDigit = oldSymbols.getZeroDigit();
- char positiveSign = '+';
- char negativeSign = oldSymbols.getMinusSign();
- char decimalSeparator = oldSymbols.getDecimalSeparator();
- if (zeroDigit == '0' && negativeSign == '-' && decimalSeparator == '.') {
- return STANDARD;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Restricted constructor.
- *
- * @param zeroChar the character to use for the digit of zero
- * @param positiveSignChar the character to use for the positive sign
- * @param negativeSignChar the character to use for the negative sign
- * @param decimalPointChar the character to use for the decimal point
- */
- private DateTimeFormatSymbols(char zeroChar, char positiveSignChar, char negativeSignChar, char decimalPointChar) {
- this.zeroDigit = zeroChar;
- this.positiveSign = positiveSignChar;
- this.negativeSign = negativeSignChar;
- this.decimalSeparator = decimalPointChar;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents zero.
- *
- * The character used to represent digits may vary by culture.
- * This method specifies the zero character to use, which implies the characters for one to nine.
- *
- * @return the character for zero
- */
- public char getZeroDigit() {
- return zeroDigit;
- }
-
- /**
- * Returns a copy of the info with a new character that represents zero.
- *
- * The character used to represent digits may vary by culture.
- * This method specifies the zero character to use, which implies the characters for one to nine.
- *
- * @param zeroDigit the character for zero
- * @return a copy with a new character that represents zero, not null
-
- */
- public DateTimeFormatSymbols withZeroDigit(char zeroDigit) {
- if (zeroDigit == this.zeroDigit) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the positive sign.
- *
- * The character used to represent a positive number may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the positive sign
- */
- public char getPositiveSign() {
- return positiveSign;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the positive sign.
- *
- * The character used to represent a positive number may vary by culture.
- * This method specifies the character to use.
- *
- * @param positiveSign the character for the positive sign
- * @return a copy with a new character that represents the positive sign, not null
- */
- public DateTimeFormatSymbols withPositiveSign(char positiveSign) {
- if (positiveSign == this.positiveSign) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the negative sign.
- *
- * The character used to represent a negative number may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the negative sign
- */
- public char getNegativeSign() {
- return negativeSign;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the negative sign.
- *
- * The character used to represent a negative number may vary by culture.
- * This method specifies the character to use.
- *
- * @param negativeSign the character for the negative sign
- * @return a copy with a new character that represents the negative sign, not null
- */
- public DateTimeFormatSymbols withNegativeSign(char negativeSign) {
- if (negativeSign == this.negativeSign) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the decimal point.
- *
- * The character used to represent a decimal point may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the decimal point
- */
- public char getDecimalSeparator() {
- return decimalSeparator;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the decimal point.
- *
- * The character used to represent a decimal point may vary by culture.
- * This method specifies the character to use.
- *
- * @param decimalSeparator the character for the decimal point
- * @return a copy with a new character that represents the decimal point, not null
- */
- public DateTimeFormatSymbols withDecimalSeparator(char decimalSeparator) {
- if (decimalSeparator == this.decimalSeparator) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Checks whether the character is a digit, based on the currently set zero character.
- *
- * @param ch the character to check
- * @return the value, 0 to 9, of the character, or -1 if not a digit
- */
- int convertToDigit(char ch) {
- int val = ch - zeroDigit;
- return (val >= 0 && val <= 9) ? val : -1;
- }
-
- /**
- * Converts the input numeric text to the internationalized form using the zero character.
- *
- * @param numericText the text, consisting of digits 0 to 9, to convert, not null
- * @return the internationalized text, not null
- */
- String convertNumberToI18N(String numericText) {
- if (zeroDigit == '0') {
- return numericText;
- }
- int diff = zeroDigit - '0';
- char[] array = numericText.toCharArray();
- for (int i = 0; i < array.length; i++) {
- array[i] = (char) (array[i] + diff);
- }
- return new String(array);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Checks if these symbols equal another set of symbols.
- *
- * @param obj the object to check, null returns false
- * @return true if this is equal to the other date
- */
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj instanceof DateTimeFormatSymbols) {
- DateTimeFormatSymbols other = (DateTimeFormatSymbols) obj;
- return (zeroDigit == other.zeroDigit && positiveSign == other.positiveSign &&
- negativeSign == other.negativeSign && decimalSeparator == other.decimalSeparator);
- }
- return false;
- }
-
- /**
- * A hash code for these symbols.
- *
- * @return a suitable hash code
- */
- @Override
- public int hashCode() {
- return zeroDigit + positiveSign + negativeSign + decimalSeparator;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Returns a string describing these symbols.
- *
- * @return a string description, not null
- */
- @Override
- public String toString() {
- return "Symbols[" + zeroDigit + positiveSign + negativeSign + decimalSeparator + "]";
- }
-
-}
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimeFormatter.java
--- a/jdk/src/share/classes/java/time/format/DateTimeFormatter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeFormatter.java Wed May 15 07:48:57 2013 -0700
@@ -77,6 +77,7 @@
import java.text.ParseException;
import java.text.ParsePosition;
import java.time.DateTimeException;
+import java.time.Period;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.chrono.Chronology;
@@ -121,7 +122,7 @@
*
*
* In addition to the format, formatters can be created with desired Locale,
- * Chronology, ZoneId, and formatting symbols.
+ * Chronology, ZoneId, and DecimalStyle.
*
* The {@link #withLocale withLocale} method returns a new formatter that
* overrides the locale. The locale affects some aspects of formatting and
@@ -138,8 +139,8 @@
* with the requested ZoneId before formatting. During parsing the ZoneId is
* applied before the value is returned.
*
- * The {@link #withSymbols withSymbols} method returns a new formatter that
- * overrides the {@link DateTimeFormatSymbols}. The symbols are used for
+ * The {@link #withDecimalStyle withDecimalStyle} method returns a new formatter that
+ * overrides the {@link DecimalStyle}. The DecimalStyle symbols are used for
* formatting and parsing.
*
* Some applications may need to use the older {@link Format java.text.Format}
@@ -417,7 +418,65 @@
* that you want to output directly to ensure that future changes do not break
* your application.
*
- *
+ * Five parsing methods are supplied by this class.
+ * Four of these perform both the parse and resolve phases.
+ * The fifth method, {@link #parseUnresolved(CharSequence, ParsePosition)},
+ * only performs the first phase, leaving the result unresolved.
+ * As such, it is essentially a low-level operation.
+ *
+ * The resolve phase is controlled by two parameters, set on this class.
+ *
+ * The {@link ResolverStyle} is an enum that offers three different approaches,
+ * strict, smart and lenient. The smart option is the default.
+ * It can be set using {@link #withResolverStyle(ResolverStyle)}.
+ *
+ * The {@link #withResolverFields(TemporalField...)} parameter allows the
+ * set of fields that will be resolved to be filtered before resolving starts.
+ * For example, if the formatter has parsed a year, month, day-of-month
+ * and day-of-year, then there are two approaches to resolve a date:
+ * (year + month + day-of-month) and (year + day-of-year).
+ * The resolver fields allows one of the two approaches to be selected.
+ * If no resolver fields are set then both approaches must result in the same date.
+ *
+ * Resolving separate fields to form a complete date and time is a complex
+ * process with behaviour distributed across a number of classes.
+ * It follows these steps:
+ *
* This returns an immutable formatter capable of formatting and parsing
* the ISO-8601 instant format.
+ * When formatting, the second-of-minute is always output.
+ * The nano-of-second outputs zero, three, six or nine digits digits as necessary.
+ * When parsing, time to at least the seconds field is required.
+ * Fractional seconds from zero to nine are parsed.
+ * The localized decimal style is not used.
*
* This is a special case formatter intended to allow a human readable form
* of an {@link java.time.Instant}. The {@code Instant} class is designed to
@@ -1201,25 +1265,117 @@
.toFormatter(ResolverStyle.SMART, IsoChronology.INSTANCE);
}
+ //-----------------------------------------------------------------------
+ /**
+ * A query that provides access to the excess days that were parsed.
+ *
+ * This returns a singleton {@linkplain TemporalQuery query} that provides
+ * access to additional information from the parse. The query always returns
+ * a non-null period, with a zero period returned instead of null.
+ *
+ * There are two situations where this query may return a non-zero period.
+ *
+ *
+ * In both cases, if a complete {@code ChronoLocalDateTime} or {@code Instant}
+ * is parsed, then the excess days are added to the date part.
+ * As a result, this query will return a zero period.
+ *
+ * The {@code SMART} behaviour handles the common "end of day" 24:00 value.
+ * Processing in {@code LENIENT} mode also produces the same result:
+ *
+ * This returns a singleton {@linkplain TemporalQuery query} that provides
+ * access to additional information from the parse. The query always returns
+ * a non-null boolean, true if parsing saw a leap-second, false if not.
+ *
+ * Instant parsing handles the special "leap second" time of '23:59:60'.
+ * Leap seconds occur at '23:59:60' in the UTC time-zone, but at other
+ * local times in different time-zones. To avoid this potential ambiguity,
+ * the handling of leap-seconds is limited to
+ * {@link DateTimeFormatterBuilder#appendInstant()}, as that method
+ * always parses the instant with the UTC zone offset.
+ *
+ * If the time '23:59:60' is received, then a simple conversion is applied,
+ * replacing the second-of-minute of 60 with 59. This query can be used
+ * on the parse result to determine if the leap-second adjustment was made.
+ * The query will return one second of excess if it did adjust to remove
+ * the leap-second, and zero if not. Note that applying a leap-second
+ * smoothing mechanism, such as UTC-SLS, is the responsibility of the
+ * application, as follows:
+ *
* This instance is immutable and unaffected by this method call.
*
- * @param symbols the new symbols, not null
- * @return a formatter based on this formatter with the requested symbols, not null
+ * @param decimalStyle the new DecimalStyle, not null
+ * @return a formatter based on this formatter with the requested DecimalStyle, not null
*/
- public DateTimeFormatter withSymbols(DateTimeFormatSymbols symbols) {
- if (this.symbols.equals(symbols)) {
+ public DateTimeFormatter withDecimalStyle(DecimalStyle decimalStyle) {
+ if (this.decimalStyle.equals(decimalStyle)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1332,7 +1488,7 @@
if (Objects.equals(this.chrono, chrono)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1389,7 +1545,7 @@
if (Objects.equals(this.zone, zone)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1431,7 +1587,7 @@
if (Objects.equals(this.resolverStyle, resolverStyle)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1495,7 +1651,7 @@
return this;
}
fields = Collections.unmodifiableSet(fields);
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, fields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, fields, chrono, zone);
}
/**
@@ -1543,7 +1699,7 @@
return this;
}
resolverFields = Collections.unmodifiableSet(new HashSet<>(resolverFields));
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimeFormatterBuilder.java
--- a/jdk/src/share/classes/java/time/format/DateTimeFormatterBuilder.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeFormatterBuilder.java Wed May 15 07:48:57 2013 -0700
@@ -77,6 +77,7 @@
import java.math.RoundingMode;
import java.text.ParsePosition;
import java.time.DateTimeException;
+import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
@@ -142,7 +143,7 @@
* can be used, see {@link #appendPattern(String)}.
* In practice, this simply parses the pattern and calls other methods on the builder.
*
- *
* This method supports a special technique of parsing known as 'adjacent value parsing'.
- * This technique solves the problem where a variable length value is followed by one or more
+ * This technique solves the problem where a value, variable or fixed width, is followed by one or more
* fixed length values. The standard parser is greedy, and thus it would normally
* steal the digits that are needed by the fixed width value parsers that follow the
* variable width one.
*
* No action is required to initiate 'adjacent value parsing'.
- * When a call to {@code appendValue} with a variable width is made, the builder
+ * When a call to {@code appendValue} is made, the builder
* enters adjacent value parsing setup mode. If the immediately subsequent method
- * call or calls on the same builder are to this method, then the parser will reserve
+ * call or calls on the same builder are for a fixed width value, then the parser will reserve
* space so that the fixed width values can be parsed.
*
* For example, consider {@code builder.appendValue(YEAR).appendValue(MONTH_OF_YEAR, 2);}
@@ -381,7 +420,7 @@
* nothing for the month.
*
* Adjacent value parsing applies to each set of fixed width not-negative values in the parser
- * that immediately follow any kind of variable width value.
+ * that immediately follow any kind of value, variable or fixed width.
* Calling any other append method will end the setup of adjacent value parsing.
* Thus, in the unlikely event that you need to avoid adjacent value parsing behavior,
* simply add the {@code appendValue} to another {@code DateTimeFormatterBuilder}
@@ -402,7 +441,8 @@
throw new IllegalArgumentException("The width must be from 1 to 19 inclusive but was " + width);
}
NumberPrinterParser pp = new NumberPrinterParser(field, width, width, SignStyle.NOT_NEGATIVE);
- return appendFixedWidth(width, pp);
+ appendValue(pp);
+ return this;
}
/**
@@ -420,8 +460,10 @@
* This behavior can be affected by 'adjacent value parsing'.
* See {@link #appendValue(java.time.temporal.TemporalField, int)} for full details.
*
- * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}.
- * In lenient parsing mode, the minimum number of parsed digits is one.
+ * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}
+ * and the maximum is {@code maxWidth}.
+ * In lenient parsing mode, the minimum number of parsed digits is one
+ * and the maximum is 19 (except as limited by adjacent value parsing).
*
* If this method is invoked with equal minimum and maximum widths and a sign style of
* {@code NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)}.
@@ -452,17 +494,13 @@
maxWidth + " < " + minWidth);
}
NumberPrinterParser pp = new NumberPrinterParser(field, minWidth, maxWidth, signStyle);
- if (minWidth == maxWidth) {
- appendInternal(pp);
- } else {
- active.valueParserIndex = appendInternal(pp);
- }
+ appendValue(pp);
return this;
}
//-----------------------------------------------------------------------
/**
- * Appends the reduced value of a date-time field to the formatter.
+ * Appends the reduced value of a date-time field with fixed width to the formatter.
*
* This is typically used for formatting and parsing a two digit year.
* The {@code width} is the printed and parsed width.
@@ -471,51 +509,116 @@
* For formatting, the width is used to determine the number of characters to format.
* The rightmost characters are output to match the width, left padding with zero.
*
- * For parsing, exactly the number of characters specified by the width are parsed.
- * This is incomplete information however, so the base value is used to complete the parse.
- * The base value is the first valid value in a range of ten to the power of width.
+ * For strict parsing, the number of characters allowed by the width are parsed.
+ * For lenient parsing, the number of characters must be at least 1 and less than 10.
+ * If the number of digits parsed is equal to {@code width} and the value is positive,
+ * the value of the field is computed to be the first number greater than
+ * or equal to the {@code baseValue} with the same least significant characters,
+ * otherwise the value parsed is the field value.
+ * This allows a reduced value to be entered for values in range of the baseValue
+ * and width and absolute values can be entered for values outside the range.
*
* For example, a base value of {@code 1980} and a width of {@code 2} will have
* valid values from {@code 1980} to {@code 2079}.
* During parsing, the text {@code "12"} will result in the value {@code 2012} as that
- * is the value within the range where the last two digits are "12".
- *
- * This is a fixed width parser operating using 'adjacent value parsing'.
- * See {@link #appendValue(java.time.temporal.TemporalField, int)} for full details.
+ * is the value within the range where the last two characters are "12".
+ * Compare with lenient parsing the text {@code "1915"} that will result in the
+ * value {@code 1915}.
*
* @param field the field to append, not null
- * @param width the width of the printed and parsed field, from 1 to 18
+ * @param width the field width of the printed and parsed field, from 1 to 10
+ * @param baseValue the base value of the range of valid values
+ * @return this, for chaining, not null
+ * @throws IllegalArgumentException if the width or base value is invalid
+ * @see #appendValueReduced(java.time.temporal.TemporalField, int, int, int)
+ */
+ public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
+ int width, int baseValue) {
+ return appendValueReduced(field, width, width, baseValue);
+ }
+
+ /**
+ * Appends the reduced value of a date-time field with a flexible width to the formatter.
+ *
+ * This is typically used for formatting and parsing a two digit year
+ * but allowing for the year value to be up to maxWidth.
+ *
+ * For formatting, the {@code width} and {@code maxWidth} are used to
+ * determine the number of characters to format.
+ * If the value of the field is within the range of the {@code baseValue} using
+ * {@code width} characters then the reduced value is formatted otherwise the value is
+ * truncated to fit {@code maxWidth}.
+ * The rightmost characters are output to match the width, left padding with zero.
+ *
+ * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are parsed.
+ * For lenient parsing, the number of characters must be at least 1 and less than 10.
+ * If the number of digits parsed is equal to {@code width} and the value is positive,
+ * the value of the field is computed to be the first number greater than
+ * or equal to the {@code baseValue} with the same least significant characters,
+ * otherwise the value parsed is the field value.
+ * This allows a reduced value to be entered for values in range of the baseValue
+ * and width and absolute values can be entered for values outside the range.
+ *
+ * For example, a base value of {@code 1980} and a width of {@code 2} will have
+ * valid values from {@code 1980} to {@code 2079}.
+ * During parsing, the text {@code "12"} will result in the value {@code 2012} as that
+ * is the value within the range where the last two characters are "12".
+ * Compare with parsing the text {@code "1915"} that will result in the
+ * value {@code 1915}.
+ *
+ * @param field the field to append, not null
+ * @param width the field width of the printed and parsed field, from 1 to 10
+ * @param maxWidth the maximum field width of the printed field, from 1 to 10
* @param baseValue the base value of the range of valid values
* @return this, for chaining, not null
* @throws IllegalArgumentException if the width or base value is invalid
*/
- public DateTimeFormatterBuilder appendValueReduced(
- TemporalField field, int width, int baseValue) {
+ public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
+ int width, int maxWidth, int baseValue) {
Objects.requireNonNull(field, "field");
- ReducedPrinterParser pp = new ReducedPrinterParser(field, width, baseValue);
- appendFixedWidth(width, pp);
+ ReducedPrinterParser pp = new ReducedPrinterParser(field, width, maxWidth, baseValue);
+ appendValue(pp);
return this;
}
/**
- * Appends a fixed width printer-parser.
+ * Appends a fixed or variable width printer-parser handling adjacent value mode.
+ * If a PrinterParser is not active then the new PrinterParser becomes
+ * the active PrinterParser.
+ * Otherwise, the active PrinterParser is modified depending on the new PrinterParser.
+ * If the new PrinterParser is fixed width and has sign style {@code NOT_NEGATIVE}
+ * then its width is added to the active PP and
+ * the new PrinterParser is forced to be fixed width.
+ * If the new PrinterParser is variable width, the active PrinterParser is changed
+ * to be fixed width and the new PrinterParser becomes the active PP.
*
- * @param width the width
* @param pp the printer-parser, not null
* @return this, for chaining, not null
*/
- private DateTimeFormatterBuilder appendFixedWidth(int width, NumberPrinterParser pp) {
+ private DateTimeFormatterBuilder appendValue(NumberPrinterParser pp) {
if (active.valueParserIndex >= 0) {
+ final int activeValueParser = active.valueParserIndex;
+
// adjacent parsing mode, update setting in previous parsers
- NumberPrinterParser basePP = (NumberPrinterParser) active.printerParsers.get(active.valueParserIndex);
- basePP = basePP.withSubsequentWidth(width);
- int activeValueParser = active.valueParserIndex;
- active.printerParsers.set(active.valueParserIndex, basePP);
- appendInternal(pp.withFixedWidth());
- active.valueParserIndex = activeValueParser;
+ NumberPrinterParser basePP = (NumberPrinterParser) active.printerParsers.get(activeValueParser);
+ if (pp.minWidth == pp.maxWidth && pp.signStyle == SignStyle.NOT_NEGATIVE) {
+ // Append the width to the subsequentWidth of the active parser
+ basePP = basePP.withSubsequentWidth(pp.maxWidth);
+ // Append the new parser as a fixed width
+ appendInternal(pp.withFixedWidth());
+ // Retain the previous active parser
+ active.valueParserIndex = activeValueParser;
+ } else {
+ // Modify the active parser to be fixed width
+ basePP = basePP.withFixedWidth();
+ // The new parser becomes the mew active parser
+ active.valueParserIndex = appendInternal(pp);
+ }
+ // Replace the modified parser with the updated one
+ active.printerParsers.set(activeValueParser, basePP);
} else {
- // not adjacent parsing
- appendInternal(pp);
+ // The new Parser becomes the active parser
+ active.valueParserIndex = appendInternal(pp);
}
return this;
}
@@ -657,11 +760,24 @@
//-----------------------------------------------------------------------
/**
- * Appends an instant using ISO-8601 to the formatter.
+ * Appends an instant using ISO-8601 to the formatter, formatting fractional
+ * digits in groups of three.
*
* Instants have a fixed output format.
- * They are converted to a date-time with a zone-offset of UTC and printed
+ * They are converted to a date-time with a zone-offset of UTC and formatted
* using the standard ISO-8601 format.
+ * With this method, formatting nano-of-second outputs zero, three, six
+ * or nine digits digits as necessary.
+ * The localized decimal style is not used.
+ *
+ * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}
+ * and optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS}
+ * may be outside the maximum range of {@code LocalDateTime}.
+ *
+ * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing.
+ * The end-of-day time of '24:00' is handled as midnight at the start of the following day.
+ * The leap-second time of '23:59:59' is handled to some degree, see
+ * {@link DateTimeFormatter#parsedLeapSecond()} for full details.
*
* An alternative to this method is to format/parse the instant as a single
* epoch-seconds value. That is achieved using {@code appendValue(INSTANT_SECONDS)}.
@@ -669,11 +785,55 @@
* @return this, for chaining, not null
*/
public DateTimeFormatterBuilder appendInstant() {
- appendInternal(new InstantPrinterParser());
+ appendInternal(new InstantPrinterParser(-2));
return this;
}
/**
+ * Appends an instant using ISO-8601 to the formatter with control over
+ * the number of fractional digits.
+ *
+ * Instants have a fixed output format, although this method provides some
+ * control over the fractional digits. They are converted to a date-time
+ * with a zone-offset of UTC and printed using the standard ISO-8601 format.
+ * The localized decimal style is not used.
+ *
+ * The {@code fractionalDigits} parameter allows the output of the fractional
+ * second to be controlled. Specifying zero will cause no fractional digits
+ * to be output. From 1 to 9 will output an increasing number of digits, using
+ * zero right-padding if necessary. The special value -1 is used to output as
+ * many digits as necessary to avoid any trailing zeroes.
+ *
+ * When parsing in strict mode, the number of parsed digits must match the
+ * fractional digits. When parsing in lenient mode, any number of fractional
+ * digits from zero to nine are accepted.
+ *
+ * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}
+ * and optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS}
+ * may be outside the maximum range of {@code LocalDateTime}.
+ *
+ * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing.
+ * The end-of-day time of '24:00' is handled as midnight at the start of the following day.
+ * The leap-second time of '23:59:59' is handled to some degree, see
+ * {@link DateTimeFormatter#parsedLeapSecond()} for full details.
+ *
+ * An alternative to this method is to format/parse the instant as a single
+ * epoch-seconds value. That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+ *
+ * @param fractionalDigits the number of fractional second digits to format with,
+ * from 0 to 9, or -1 to use as many digits as necessary
+ * @return this, for chaining, not null
+ */
+ public DateTimeFormatterBuilder appendInstant(int fractionalDigits) {
+ if (fractionalDigits < -1 || fractionalDigits > 9) {
+ throw new IllegalArgumentException("The fractional digits must be from -1 to 9 inclusive but was " + fractionalDigits);
+ }
+ appendInternal(new InstantPrinterParser(fractionalDigits));
+ return this;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
* Appends the zone offset, such as '+01:00', to the formatter.
*
* This appends an instruction to format/parse the offset ID to the builder.
@@ -1049,7 +1209,7 @@
*
* The calendar system name will be output during a format.
* If the chronology cannot be obtained then an exception will be thrown.
- * The calendar system name is obtained from the formatting symbols.
+ * The calendar system name is obtained from the Chronology.
*
* @param textStyle the text style to use, not null
* @return this, for chaining, not null
@@ -1838,7 +1998,7 @@
* using the default locale.
*
* This will create a formatter with the {@linkplain Locale#getDefault(Locale.Category) default FORMAT locale}.
- * Numbers will be printed and parsed using the standard non-localized set of symbols.
+ * Numbers will be printed and parsed using the standard DecimalStyle.
* The resolver style will be {@link ResolverStyle#SMART SMART}.
*
* Calling this method will end any open optional sections by repeatedly
@@ -1858,7 +2018,7 @@
* using the specified locale.
*
* This will create a formatter with the specified locale.
- * Numbers will be printed and parsed using the standard non-localized set of symbols.
+ * Numbers will be printed and parsed using the standard DecimalStyle.
* The resolver style will be {@link ResolverStyle#SMART SMART}.
*
* Calling this method will end any open optional sections by repeatedly
@@ -1898,7 +2058,7 @@
optionalEnd();
}
CompositePrinterParser pp = new CompositePrinterParser(printerParsers, false);
- return new DateTimeFormatter(pp, locale, DateTimeFormatSymbols.STANDARD,
+ return new DateTimeFormatter(pp, locale, DecimalStyle.STANDARD,
resolverStyle, null, chrono, null);
}
@@ -1921,7 +2081,7 @@
* for the next parser. If an error occurs, the returned index will be negative
* and will have the error position encoded using the complement operator.
*
- *
@@ -2282,24 +2442,25 @@
/**
* Array of 10 to the power of n.
*/
- static final int[] EXCEED_POINTS = new int[] {
- 0,
- 10,
- 100,
- 1000,
- 10000,
- 100000,
- 1000000,
- 10000000,
- 100000000,
- 1000000000,
+ static final long[] EXCEED_POINTS = new long[] {
+ 0L,
+ 10L,
+ 100L,
+ 1000L,
+ 10000L,
+ 100000L,
+ 1000000L,
+ 10000000L,
+ 100000000L,
+ 1000000000L,
+ 10000000000L,
};
final TemporalField field;
final int minWidth;
- private final int maxWidth;
+ final int maxWidth;
private final SignStyle signStyle;
- private final int subsequentWidth;
+ final int subsequentWidth;
/**
* Constructor.
@@ -2328,7 +2489,7 @@
* @param subsequentWidth the width of subsequent non-negative numbers, 0 or greater,
* -1 if fixed width due to active adjacent parsing
*/
- private NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle, int subsequentWidth) {
+ protected NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle, int subsequentWidth) {
// validated by caller
this.field = field;
this.minWidth = minWidth;
@@ -2343,6 +2504,9 @@
* @return a new updated printer-parser, not null
*/
NumberPrinterParser withFixedWidth() {
+ if (subsequentWidth == -1) {
+ return this;
+ }
return new NumberPrinterParser(field, minWidth, maxWidth, signStyle, -1);
}
@@ -2363,24 +2527,24 @@
return false;
}
long value = getValue(valueLong);
- DateTimeFormatSymbols symbols = context.getSymbols();
+ DecimalStyle decimalStyle = context.getDecimalStyle();
String str = (value == Long.MIN_VALUE ? "9223372036854775808" : Long.toString(Math.abs(value)));
if (str.length() > maxWidth) {
throw new DateTimeException("Field " + field.getName() +
" cannot be printed as the value " + value +
" exceeds the maximum print width of " + maxWidth);
}
- str = symbols.convertNumberToI18N(str);
+ str = decimalStyle.convertNumberToI18N(str);
if (value >= 0) {
switch (signStyle) {
case EXCEEDS_PAD:
if (minWidth < 19 && value >= EXCEED_POINTS[minWidth]) {
- buf.append(symbols.getPositiveSign());
+ buf.append(decimalStyle.getPositiveSign());
}
break;
case ALWAYS:
- buf.append(symbols.getPositiveSign());
+ buf.append(decimalStyle.getPositiveSign());
break;
}
} else {
@@ -2388,7 +2552,7 @@
case NORMAL:
case EXCEEDS_PAD:
case ALWAYS:
- buf.append(symbols.getNegativeSign());
+ buf.append(decimalStyle.getNegativeSign());
break;
case NOT_NEGATIVE:
throw new DateTimeException("Field " + field.getName() +
@@ -2397,7 +2561,7 @@
}
}
for (int i = 0; i < minWidth - str.length(); i++) {
- buf.append(symbols.getZeroDigit());
+ buf.append(decimalStyle.getZeroDigit());
}
buf.append(str);
return true;
@@ -2426,13 +2590,13 @@
char sign = text.charAt(position); // IOOBE if invalid position
boolean negative = false;
boolean positive = false;
- if (sign == context.getSymbols().getPositiveSign()) {
+ if (sign == context.getDecimalStyle().getPositiveSign()) {
if (signStyle.parse(true, context.isStrict(), minWidth == maxWidth) == false) {
return ~position;
}
positive = true;
position++;
- } else if (sign == context.getSymbols().getNegativeSign()) {
+ } else if (sign == context.getDecimalStyle().getNegativeSign()) {
if (signStyle.parse(false, context.isStrict(), minWidth == maxWidth) == false) {
return ~position;
}
@@ -2448,7 +2612,7 @@
if (minEndPos > length) {
return ~position;
}
- int effMaxWidth = maxWidth + Math.max(subsequentWidth, 0);
+ int effMaxWidth = (context.isStrict() || isFixedWidth() ? maxWidth : 9) + Math.max(subsequentWidth, 0);
long total = 0;
BigInteger totalBig = null;
int pos = position;
@@ -2456,7 +2620,7 @@
int maxEndPos = Math.min(pos + effMaxWidth, length);
while (pos < maxEndPos) {
char ch = text.charAt(pos++);
- int digit = context.getSymbols().convertToDigit(ch);
+ int digit = context.getDecimalStyle().convertToDigit(ch);
if (digit < 0) {
pos--;
if (pos < minEndPos) {
@@ -2550,62 +2714,110 @@
*/
static final class ReducedPrinterParser extends NumberPrinterParser {
private final int baseValue;
- private final int range;
/**
* Constructor.
*
* @param field the field to format, validated not null
- * @param width the field width, from 1 to 18
+ * @param minWidth the minimum field width, from 1 to 10
+ * @param maxWidth the maximum field width, from 1 to 10
* @param baseValue the base value
*/
- ReducedPrinterParser(TemporalField field, int width, int baseValue) {
- super(field, width, width, SignStyle.NOT_NEGATIVE);
- if (width < 1 || width > 18) {
- throw new IllegalArgumentException("The width must be from 1 to 18 inclusive but was " + width);
+ ReducedPrinterParser(TemporalField field, int minWidth, int maxWidth,
+ int baseValue) {
+ this(field, minWidth, maxWidth, baseValue, 0);
+ if (minWidth < 1 || minWidth > 10) {
+ throw new IllegalArgumentException("The minWidth must be from 1 to 10 inclusive but was " + minWidth);
+ }
+ if (maxWidth < 1 || maxWidth > 10) {
+ throw new IllegalArgumentException("The maxWidth must be from 1 to 10 inclusive but was " + minWidth);
+ }
+ if (maxWidth < minWidth) {
+ throw new IllegalArgumentException("Maximum width must exceed or equal the minimum width but " +
+ maxWidth + " < " + minWidth);
}
if (field.range().isValidValue(baseValue) == false) {
throw new IllegalArgumentException("The base value must be within the range of the field");
}
- this.baseValue = baseValue;
- this.range = EXCEED_POINTS[width];
- if ((((long) baseValue) + range) > Integer.MAX_VALUE) {
+ if ((((long) baseValue) + EXCEED_POINTS[maxWidth]) > Integer.MAX_VALUE) {
throw new DateTimeException("Unable to add printer-parser as the range exceeds the capacity of an int");
}
}
+ /**
+ * Constructor.
+ * The arguments have already been checked.
+ *
+ * @param field the field to format, validated not null
+ * @param minWidth the minimum field width, from 1 to 10
+ * @param maxWidth the maximum field width, from 1 to 10
+ * @param baseValue the base value
+ * @param subsequentWidth the subsequentWidth for this instance
+ */
+ private ReducedPrinterParser(TemporalField field, int minWidth, int maxWidth,
+ int baseValue, int subsequentWidth) {
+ super(field, minWidth, maxWidth, SignStyle.NOT_NEGATIVE, subsequentWidth);
+ this.baseValue = baseValue;
+ }
+
@Override
long getValue(long value) {
- return Math.abs(value % range);
+ long absValue = Math.abs(value);
+ if (value >= baseValue && value < baseValue + EXCEED_POINTS[minWidth]) {
+ // Use the reduced value if it fits in minWidth
+ return absValue % EXCEED_POINTS[minWidth];
+ }
+ // Otherwise truncate to fit in maxWidth
+ return absValue % EXCEED_POINTS[maxWidth];
}
@Override
int setValue(DateTimeParseContext context, long value, int errorPos, int successPos) {
- int lastPart = baseValue % range;
- if (baseValue > 0) {
- value = baseValue - lastPart + value;
- } else {
- value = baseValue - lastPart - value;
- }
- if (value < baseValue) {
- value += range;
+ int parseLen = successPos - errorPos;
+ if (parseLen == minWidth && value >= 0) {
+ long range = EXCEED_POINTS[minWidth];
+ long lastPart = baseValue % range;
+ long basePart = baseValue - lastPart;
+ if (baseValue > 0) {
+ value = basePart + value;
+ } else {
+ value = basePart - value;
+ }
+ if (basePart != 0 && value < baseValue) {
+ value += range;
+ }
}
return context.setParsedField(field, value, errorPos, successPos);
}
+ /**
+ * Returns a new instance with fixed width flag set.
+ *
+ * @return a new updated printer-parser, not null
+ */
@Override
- NumberPrinterParser withFixedWidth() {
- return this;
+ ReducedPrinterParser withFixedWidth() {
+ if (subsequentWidth == -1) {
+ return this;
+ }
+ return new ReducedPrinterParser(field, minWidth, maxWidth, baseValue, -1);
}
+ /**
+ * Returns a new instance with an updated subsequent width.
+ *
+ * @param subsequentWidth the width of subsequent non-negative numbers, 0 or greater
+ * @return a new updated printer-parser, not null
+ */
@Override
- boolean isFixedWidth() {
- return true;
+ ReducedPrinterParser withSubsequentWidth(int subsequentWidth) {
+ return new ReducedPrinterParser(field, minWidth, maxWidth, baseValue,
+ this.subsequentWidth + subsequentWidth);
}
@Override
public String toString() {
- return "ReducedValue(" + field.getName() + "," + minWidth + "," + baseValue + ")";
+ return "ReducedValue(" + field.getName() + "," + minWidth + "," + maxWidth + "," + baseValue + ")";
}
}
@@ -2654,24 +2866,24 @@
if (value == null) {
return false;
}
- DateTimeFormatSymbols symbols = context.getSymbols();
+ DecimalStyle decimalStyle = context.getDecimalStyle();
BigDecimal fraction = convertToFraction(value);
if (fraction.scale() == 0) { // scale is zero if value is zero
if (minWidth > 0) {
if (decimalPoint) {
- buf.append(symbols.getDecimalSeparator());
+ buf.append(decimalStyle.getDecimalSeparator());
}
for (int i = 0; i < minWidth; i++) {
- buf.append(symbols.getZeroDigit());
+ buf.append(decimalStyle.getZeroDigit());
}
}
} else {
int outputScale = Math.min(Math.max(fraction.scale(), minWidth), maxWidth);
fraction = fraction.setScale(outputScale, RoundingMode.FLOOR);
String str = fraction.toPlainString().substring(2);
- str = symbols.convertNumberToI18N(str);
+ str = decimalStyle.convertNumberToI18N(str);
if (decimalPoint) {
- buf.append(symbols.getDecimalSeparator());
+ buf.append(decimalStyle.getDecimalSeparator());
}
buf.append(str);
}
@@ -2688,7 +2900,7 @@
return (effectiveMin > 0 ? ~position : position);
}
if (decimalPoint) {
- if (text.charAt(position) != context.getSymbols().getDecimalSeparator()) {
+ if (text.charAt(position) != context.getDecimalStyle().getDecimalSeparator()) {
// valid if whole field is optional, invalid if minimum width
return (effectiveMin > 0 ? ~position : position);
}
@@ -2703,7 +2915,7 @@
int pos = position;
while (pos < maxEndPos) {
char ch = text.charAt(pos++);
- int digit = context.getSymbols().convertToDigit(ch);
+ int digit = context.getDecimalStyle().convertToDigit(ch);
if (digit < 0) {
if (pos < minEndPos) {
return ~position; // need at least min width digits
@@ -2883,43 +3095,50 @@
// seconds per day = 86400
private static final long SECONDS_PER_10000_YEARS = 146097L * 25L * 86400L;
private static final long SECONDS_0000_TO_1970 = ((146097L * 5L) - (30L * 365L + 7L)) * 86400L;
- private static final CompositePrinterParser PARSER = new DateTimeFormatterBuilder()
- .parseCaseInsensitive()
- .append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T')
- .append(DateTimeFormatter.ISO_LOCAL_TIME).appendLiteral('Z')
- .toFormatter().toPrinterParser(false);
+ private final int fractionalDigits;
- InstantPrinterParser() {
+ InstantPrinterParser(int fractionalDigits) {
+ this.fractionalDigits = fractionalDigits;
}
@Override
public boolean format(DateTimePrintContext context, StringBuilder buf) {
// use INSTANT_SECONDS, thus this code is not bound by Instant.MAX
Long inSecs = context.getValue(INSTANT_SECONDS);
- Long inNanos = context.getValue(NANO_OF_SECOND);
- if (inSecs == null || inNanos == null) {
+ Long inNanos = null;
+ if (context.getTemporal().isSupported(NANO_OF_SECOND)) {
+ inNanos = context.getTemporal().getLong(NANO_OF_SECOND);
+ }
+ if (inSecs == null) {
return false;
}
long inSec = inSecs;
- int inNano = NANO_OF_SECOND.checkValidIntValue(inNanos);
+ int inNano = NANO_OF_SECOND.checkValidIntValue(inNanos != null ? inNanos : 0);
+ // format mostly using LocalDateTime.toString
if (inSec >= -SECONDS_0000_TO_1970) {
// current era
long zeroSecs = inSec - SECONDS_PER_10000_YEARS + SECONDS_0000_TO_1970;
long hi = Math.floorDiv(zeroSecs, SECONDS_PER_10000_YEARS) + 1;
long lo = Math.floorMod(zeroSecs, SECONDS_PER_10000_YEARS);
- LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, inNano, ZoneOffset.UTC);
+ LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, 0, ZoneOffset.UTC);
if (hi > 0) {
buf.append('+').append(hi);
}
- buf.append(ldt).append('Z');
+ buf.append(ldt);
+ if (ldt.getSecond() == 0) {
+ buf.append(":00");
+ }
} else {
// before current era
long zeroSecs = inSec + SECONDS_0000_TO_1970;
long hi = zeroSecs / SECONDS_PER_10000_YEARS;
long lo = zeroSecs % SECONDS_PER_10000_YEARS;
- LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, inNano, ZoneOffset.UTC);
+ LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, 0, ZoneOffset.UTC);
int pos = buf.length();
- buf.append(ldt).append('Z');
+ buf.append(ldt);
+ if (ldt.getSecond() == 0) {
+ buf.append(":00");
+ }
if (hi < 0) {
if (ldt.getYear() == -10_000) {
buf.replace(pos, pos + 2, Long.toString(hi - 1));
@@ -2930,14 +3149,38 @@
}
}
}
+ // add fraction
+ if ((fractionalDigits < 0 && inNano > 0) || fractionalDigits > 0) {
+ buf.append('.');
+ int div = 100_000_000;
+ for (int i = 0; ((fractionalDigits == -1 && inNano > 0) ||
+ (fractionalDigits == -2 && (inNano > 0 || (i % 3) != 0)) ||
+ i < fractionalDigits); i++) {
+ int digit = inNano / div;
+ buf.append((char) (digit + '0'));
+ inNano = inNano - (digit * div);
+ div = div / 10;
+ }
+ }
+ buf.append('Z');
return true;
}
@Override
public int parse(DateTimeParseContext context, CharSequence text, int position) {
// new context to avoid overwriting fields like year/month/day
+ int minDigits = (fractionalDigits < 0 ? 0 : fractionalDigits);
+ int maxDigits = (fractionalDigits < 0 ? 9 : fractionalDigits);
+ CompositePrinterParser parser = new DateTimeFormatterBuilder()
+ .append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T')
+ .appendValue(HOUR_OF_DAY, 2).appendLiteral(':')
+ .appendValue(MINUTE_OF_HOUR, 2).appendLiteral(':')
+ .appendValue(SECOND_OF_MINUTE, 2)
+ .appendFraction(NANO_OF_SECOND, minDigits, maxDigits, true)
+ .appendLiteral('Z')
+ .toFormatter().toPrinterParser(false);
DateTimeParseContext newContext = context.copy();
- int pos = PARSER.parse(newContext, text, position);
+ int pos = parser.parse(newContext, text, position);
if (pos < 0) {
return pos;
}
@@ -2952,10 +3195,18 @@
Long nanoVal = newContext.getParsed(NANO_OF_SECOND);
int sec = (secVal != null ? secVal.intValue() : 0);
int nano = (nanoVal != null ? nanoVal.intValue() : 0);
+ int days = 0;
+ if (hour == 24 && min == 0 && sec == 0 && nano == 0) {
+ hour = 0;
+ days = 1;
+ } else if (hour == 23 && min == 59 && sec == 60) {
+ context.setParsedLeapSecond();
+ sec = 59;
+ }
int year = (int) yearParsed % 10_000;
long instantSecs;
try {
- LocalDateTime ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0);
+ LocalDateTime ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0).plusDays(days);
instantSecs = ldt.toEpochSecond(ZoneOffset.UTC);
instantSecs += Math.multiplyExact(yearParsed / 10_000L, SECONDS_PER_10000_YEARS);
} catch (RuntimeException ex) {
@@ -4017,9 +4268,7 @@
String key = chrono.getId() + '|' + locale.toString() + '|' + dateStyle + timeStyle;
DateTimeFormatter formatter = FORMATTER_CACHE.get(key);
if (formatter == null) {
- LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased().getLocaleResources(locale);
- String pattern = lr.getJavaTimeDateTimePattern(
- convertStyle(timeStyle), convertStyle(dateStyle), chrono.getCalendarType());
+ String pattern = getLocalizedDateTimePattern(dateStyle, timeStyle, chrono, locale);
formatter = new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter(locale);
DateTimeFormatter old = FORMATTER_CACHE.putIfAbsent(key, formatter);
if (old != null) {
@@ -4029,19 +4278,6 @@
return formatter;
}
- /**
- * Converts the given FormatStyle to the java.text.DateFormat style.
- *
- * @param style the FormatStyle style
- * @return the int style, or -1 if style is null, indicating unrequired
- */
- private int convertStyle(FormatStyle style) {
- if (style == null) {
- return -1;
- }
- return style.ordinal(); // indices happen to align
- }
-
@Override
public String toString() {
return "Localized(" + (dateStyle != null ? dateStyle : "") + "," +
@@ -4096,7 +4332,7 @@
case 'Y':
field = weekDef.weekBasedYear();
if (count == 2) {
- return new ReducedPrinterParser(field, 2, 2000);
+ return new ReducedPrinterParser(field, 2, 2, 2000, 0);
} else {
return new NumberPrinterParser(field, count, 19,
(count < 4) ? SignStyle.NORMAL : SignStyle.EXCEEDS_PAD, -1);
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimeParseContext.java
--- a/jdk/src/share/classes/java/time/format/DateTimeParseContext.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeParseContext.java Wed May 15 07:48:57 2013 -0700
@@ -61,6 +61,7 @@
*/
package java.time.format;
+import java.time.Duration;
import java.time.ZoneId;
import java.time.chrono.Chronology;
import java.time.chrono.IsoChronology;
@@ -79,7 +80,7 @@
* Once parsing is complete, the {@link #toParsed()} is used to obtain the data.
* It contains a method to resolve the separate parsed fields into meaningful values.
*
- *
* This locale is used to control localization in the parse except
- * where localization is controlled by the symbols.
+ * where localization is controlled by the DecimalStyle.
*
* @return the locale, not null
*/
@@ -137,14 +142,14 @@
}
/**
- * Gets the formatting symbols.
+ * Gets the DecimalStyle.
*
- * The symbols control the localization of numeric parsing.
+ * The DecimalStyle controls the numeric parsing.
*
- * @return the formatting symbols, not null
+ * @return the DecimalStyle, not null
*/
- DateTimeFormatSymbols getSymbols() {
- return formatter.getSymbols();
+ DecimalStyle getDecimalStyle() {
+ return formatter.getDecimalStyle();
}
/**
@@ -370,6 +375,13 @@
currentParsed().zone = zone;
}
+ /**
+ * Stores the parsed leap second.
+ */
+ void setParsedLeapSecond() {
+ currentParsed().leapSecond = true;
+ }
+
//-----------------------------------------------------------------------
/**
* Returns a string version of the context for debugging.
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimeParseException.java
--- a/jdk/src/share/classes/java/time/format/DateTimeParseException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeParseException.java Wed May 15 07:48:57 2013 -0700
@@ -68,7 +68,7 @@
*
* This exception includes the text being parsed and the error index.
*
- *
* This class provides a single wrapper to items used in the format.
*
- *
* This locale is used to control localization in the format output except
- * where localization is controlled by the symbols.
+ * where localization is controlled by the DecimalStyle.
*
* @return the locale, not null
*/
@@ -243,14 +243,14 @@
}
/**
- * Gets the formatting symbols.
+ * Gets the DecimalStyle.
*
- * The symbols control the localization of numeric output.
+ * The DecimalStyle controls the localization of numeric output.
*
- * @return the formatting symbols, not null
+ * @return the DecimalStyle, not null
*/
- DateTimeFormatSymbols getSymbols() {
- return formatter.getSymbols();
+ DecimalStyle getDecimalStyle() {
+ return formatter.getDecimalStyle();
}
//-----------------------------------------------------------------------
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimeTextProvider.java
--- a/jdk/src/share/classes/java/time/format/DateTimeTextProvider.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeTextProvider.java Wed May 15 07:48:57 2013 -0700
@@ -94,7 +94,7 @@
/**
* A provider to obtain the textual form of a date-time field.
*
- *
+ * A significant part of dealing with dates and times is the localization.
+ * This class acts as a central point for accessing the information.
+ *
+ * @implSpec
+ * This class is immutable and thread-safe.
+ *
+ * @since 1.8
+ */
+public final class DecimalStyle {
+
+ /**
+ * The standard set of non-localized decimal style symbols.
+ *
+ * This uses standard ASCII characters for zero, positive, negative and a dot for the decimal point.
+ */
+ public static final DecimalStyle STANDARD = new DecimalStyle('0', '+', '-', '.');
+ /**
+ * The cache of DecimalStyle instances.
+ */
+ private static final ConcurrentMap
+ * The locale 'en_US' will always be present.
+ *
+ * @return a Set of Locales for which localization is supported
+ */
+ public static Set
+ * This method provides access to locale sensitive decimal style symbols.
+ *
+ * This is equivalent to calling
+ * {@link #of(Locale)
+ * of(Locale.getDefault(Locale.Category.FORMAT))}.
+ *
+ * @see java.util.Locale.Category#FORMAT
+ * @return the info, not null
+ */
+ public static DecimalStyle ofDefaultLocale() {
+ return of(Locale.getDefault(Locale.Category.FORMAT));
+ }
+
+ /**
+ * Obtains the DecimalStyle for the specified locale.
+ *
+ * This method provides access to locale sensitive decimal style symbols.
+ *
+ * @param locale the locale, not null
+ * @return the info, not null
+ */
+ public static DecimalStyle of(Locale locale) {
+ Objects.requireNonNull(locale, "locale");
+ DecimalStyle info = CACHE.get(locale);
+ if (info == null) {
+ info = create(locale);
+ CACHE.putIfAbsent(locale, info);
+ info = CACHE.get(locale);
+ }
+ return info;
+ }
+
+ private static DecimalStyle create(Locale locale) {
+ DecimalFormatSymbols oldSymbols = DecimalFormatSymbols.getInstance(locale);
+ char zeroDigit = oldSymbols.getZeroDigit();
+ char positiveSign = '+';
+ char negativeSign = oldSymbols.getMinusSign();
+ char decimalSeparator = oldSymbols.getDecimalSeparator();
+ if (zeroDigit == '0' && negativeSign == '-' && decimalSeparator == '.') {
+ return STANDARD;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Restricted constructor.
+ *
+ * @param zeroChar the character to use for the digit of zero
+ * @param positiveSignChar the character to use for the positive sign
+ * @param negativeSignChar the character to use for the negative sign
+ * @param decimalPointChar the character to use for the decimal point
+ */
+ private DecimalStyle(char zeroChar, char positiveSignChar, char negativeSignChar, char decimalPointChar) {
+ this.zeroDigit = zeroChar;
+ this.positiveSign = positiveSignChar;
+ this.negativeSign = negativeSignChar;
+ this.decimalSeparator = decimalPointChar;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents zero.
+ *
+ * The character used to represent digits may vary by culture.
+ * This method specifies the zero character to use, which implies the characters for one to nine.
+ *
+ * @return the character for zero
+ */
+ public char getZeroDigit() {
+ return zeroDigit;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents zero.
+ *
+ * The character used to represent digits may vary by culture.
+ * This method specifies the zero character to use, which implies the characters for one to nine.
+ *
+ * @param zeroDigit the character for zero
+ * @return a copy with a new character that represents zero, not null
+
+ */
+ public DecimalStyle withZeroDigit(char zeroDigit) {
+ if (zeroDigit == this.zeroDigit) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the positive sign.
+ *
+ * The character used to represent a positive number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the positive sign
+ */
+ public char getPositiveSign() {
+ return positiveSign;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the positive sign.
+ *
+ * The character used to represent a positive number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param positiveSign the character for the positive sign
+ * @return a copy with a new character that represents the positive sign, not null
+ */
+ public DecimalStyle withPositiveSign(char positiveSign) {
+ if (positiveSign == this.positiveSign) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the negative sign.
+ *
+ * The character used to represent a negative number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the negative sign
+ */
+ public char getNegativeSign() {
+ return negativeSign;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the negative sign.
+ *
+ * The character used to represent a negative number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param negativeSign the character for the negative sign
+ * @return a copy with a new character that represents the negative sign, not null
+ */
+ public DecimalStyle withNegativeSign(char negativeSign) {
+ if (negativeSign == this.negativeSign) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the decimal point.
+ *
+ * The character used to represent a decimal point may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the decimal point
+ */
+ public char getDecimalSeparator() {
+ return decimalSeparator;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the decimal point.
+ *
+ * The character used to represent a decimal point may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param decimalSeparator the character for the decimal point
+ * @return a copy with a new character that represents the decimal point, not null
+ */
+ public DecimalStyle withDecimalSeparator(char decimalSeparator) {
+ if (decimalSeparator == this.decimalSeparator) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks whether the character is a digit, based on the currently set zero character.
+ *
+ * @param ch the character to check
+ * @return the value, 0 to 9, of the character, or -1 if not a digit
+ */
+ int convertToDigit(char ch) {
+ int val = ch - zeroDigit;
+ return (val >= 0 && val <= 9) ? val : -1;
+ }
+
+ /**
+ * Converts the input numeric text to the internationalized form using the zero character.
+ *
+ * @param numericText the text, consisting of digits 0 to 9, to convert, not null
+ * @return the internationalized text, not null
+ */
+ String convertNumberToI18N(String numericText) {
+ if (zeroDigit == '0') {
+ return numericText;
+ }
+ int diff = zeroDigit - '0';
+ char[] array = numericText.toCharArray();
+ for (int i = 0; i < array.length; i++) {
+ array[i] = (char) (array[i] + diff);
+ }
+ return new String(array);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks if this DecimalStyle is equal another DecimalStyle.
+ *
+ * @param obj the object to check, null returns false
+ * @return true if this is equal to the other date
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof DecimalStyle) {
+ DecimalStyle other = (DecimalStyle) obj;
+ return (zeroDigit == other.zeroDigit && positiveSign == other.positiveSign &&
+ negativeSign == other.negativeSign && decimalSeparator == other.decimalSeparator);
+ }
+ return false;
+ }
+
+ /**
+ * A hash code for this DecimalStyle.
+ *
+ * @return a suitable hash code
+ */
+ @Override
+ public int hashCode() {
+ return zeroDigit + positiveSign + negativeSign + decimalSeparator;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Returns a string describing this DecimalStyle.
+ *
+ * @return a string description, not null
+ */
+ @Override
+ public String toString() {
+ return "DecimalStyle[" + zeroDigit + positiveSign + negativeSign + decimalSeparator + "]";
+ }
+
+}
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/FormatStyle.java
--- a/jdk/src/share/classes/java/time/format/FormatStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/FormatStyle.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
* These styles are used when obtaining a date-time style from configuration.
* See {@link DateTimeFormatter} and {@link DateTimeFormatterBuilder} for usage.
*
- *
* For example, resolving year-month and day-of-month in the ISO calendar
- * system using smart mode will ensure that the day-of-month is valid
- * for the year-month, rejecting invalid values, with the exception that
- * February 29th in a year other than a leap year will be converted to
- * February 28th.
+ * system using smart mode will ensure that the day-of-month is from
+ * 1 to 31, converting any value beyond the last valid day-of-month to be
+ * the last valid day-of-month.
*/
SMART,
/**
@@ -110,6 +109,7 @@
*
* For example, lenient mode allows the month in the ISO calendar system
* to be outside the range 1 to 12.
+ * For example, month 15 is treated as being 3 months after month 12.
*/
LENIENT;
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/SignStyle.java
--- a/jdk/src/share/classes/java/time/format/SignStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/SignStyle.java Wed May 15 07:48:57 2013 -0700
@@ -68,7 +68,7 @@
* to be controlled using this enum.
* See {@link DateTimeFormatterBuilder} for usage.
*
- *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MILLI_OF_SECOND} and {@code MICRO_OF_SECOND}.
*/
NANO_OF_SECOND("NanoOfSecond", NANOS, SECONDS, ValueRange.of(0, 999_999_999)),
/**
@@ -126,6 +130,11 @@
* This field is used to represent the nano-of-day handling any fraction of the second.
* Implementations of {@code TemporalAccessor} should provide a value for this field if
* they can return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code NANO_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
NANO_OF_DAY("NanoOfDay", NANOS, DAYS, ValueRange.of(0, 86400L * 1000_000_000L - 1)),
/**
@@ -141,6 +150,11 @@
*
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_SECOND} with the value multiplied by 1,000.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MILLI_OF_SECOND} to produce
+ * {@code NANO_OF_SECOND}.
*/
MICRO_OF_SECOND("MicroOfSecond", MICROS, SECONDS, ValueRange.of(0, 999_999)),
/**
@@ -155,6 +169,11 @@
*
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_DAY} with the value multiplied by 1,000.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MICRO_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MICRO_OF_DAY("MicroOfDay", MICROS, DAYS, ValueRange.of(0, 86400L * 1000_000L - 1)),
/**
@@ -170,6 +189,11 @@
*
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_SECOND} with the value multiplied by 1,000,000.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MICRO_OF_SECOND} to produce
+ * {@code NANO_OF_SECOND}.
*/
MILLI_OF_SECOND("MilliOfSecond", MILLIS, SECONDS, ValueRange.of(0, 999)),
/**
@@ -184,6 +208,11 @@
*
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_DAY} with the value multiplied by 1,000,000.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MILLI_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MILLI_OF_DAY("MilliOfDay", MILLIS, DAYS, ValueRange.of(0, 86400L * 1000L - 1)),
/**
@@ -191,6 +220,9 @@
*
* This counts the second within the minute, from 0 to 59.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
*/
SECOND_OF_MINUTE("SecondOfMinute", SECONDS, MINUTES, ValueRange.of(0, 59), "second"),
/**
@@ -198,6 +230,11 @@
*
* This counts the second within the day, from 0 to (24 * 60 * 60) - 1.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code SECOND_OF_MINUTE}, {@code MINUTE_OF_HOUR}
+ * and {@code HOUR_OF_DAY} fields.
*/
SECOND_OF_DAY("SecondOfDay", SECONDS, DAYS, ValueRange.of(0, 86400L - 1)),
/**
@@ -205,6 +242,9 @@
*
* This counts the minute within the hour, from 0 to 59.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
*/
MINUTE_OF_HOUR("MinuteOfHour", MINUTES, HOURS, ValueRange.of(0, 59), "minute"),
/**
@@ -212,6 +252,10 @@
*
* This counts the minute within the day, from 0 to (24 * 60) - 1.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MINUTE_OF_DAY("MinuteOfDay", MINUTES, DAYS, ValueRange.of(0, (24 * 60) - 1)),
/**
@@ -220,6 +264,12 @@
* This counts the hour within the AM/PM, from 0 to 11.
* This is the hour that would be observed on a standard 12-hour digital clock.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 0 to 11 in strict and smart mode.
+ * In lenient mode the value is not validated. It is combined with
+ * {@code AMPM_OF_DAY} to form {@code HOUR_OF_DAY} by multiplying
+ * the {AMPM_OF_DAY} value by 12.
*/
HOUR_OF_AMPM("HourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(0, 11)),
/**
@@ -228,6 +278,12 @@
* This counts the hour within the AM/PM, from 1 to 12.
* This is the hour that would be observed on a standard 12-hour analog wall clock.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 1 to 12 in strict mode and from
+ * 0 to 12 in smart mode. In lenient mode the value is not validated.
+ * The field is converted to an {@code HOUR_OF_AMPM} with the same value,
+ * unless the value is 12, in which case it is converted to 0.
*/
CLOCK_HOUR_OF_AMPM("ClockHourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(1, 12)),
/**
@@ -236,6 +292,13 @@
* This counts the hour within the day, from 0 to 23.
* This is the hour that would be observed on a standard 24-hour digital clock.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is combined with {@code MINUTE_OF_HOUR}, {@code SECOND_OF_MINUTE} and
+ * {@code NANO_OF_SECOND} to produce a {@code LocalTime}.
+ * In lenient mode, any excess days are added to the parsed date, or
+ * made available via {@link java.time.format.DateTimeFormatter#parsedExcessDays()}.
*/
HOUR_OF_DAY("HourOfDay", HOURS, DAYS, ValueRange.of(0, 23), "hour"),
/**
@@ -244,6 +307,12 @@
* This counts the hour within the AM/PM, from 1 to 24.
* This is the hour that would be observed on a 24-hour analog wall clock.
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 1 to 24 in strict mode and from
+ * 0 to 24 in smart mode. In lenient mode the value is not validated.
+ * The field is converted to an {@code HOUR_OF_DAY} with the same value,
+ * unless the value is 24, in which case it is converted to 0.
*/
CLOCK_HOUR_OF_DAY("ClockHourOfDay", HOURS, DAYS, ValueRange.of(1, 24)),
/**
@@ -251,6 +320,12 @@
*
* This counts the AM/PM within the day, from 0 (AM) to 1 (PM).
* This field has the same meaning for all calendar systems.
+ *
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 0 to 1 in strict and smart mode.
+ * In lenient mode the value is not validated. It is combined with
+ * {@code HOUR_OF_AMPM} to form {@code HOUR_OF_DAY} by multiplying
+ * the {AMPM_OF_DAY} value by 12.
*/
AMPM_OF_DAY("AmPmOfDay", HALF_DAYS, DAYS, ValueRange.of(0, 1), "dayperiod"),
/**
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/ChronoUnit.java
--- a/jdk/src/share/classes/java/time/temporal/ChronoUnit.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ChronoUnit.java Wed May 15 07:48:57 2013 -0700
@@ -72,7 +72,7 @@
* just with slightly different rules.
* The documentation of each unit explains how it operates.
*
- *
* This class is immutable and thread-safe.
*
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/JulianFields.java
--- a/jdk/src/share/classes/java/time/temporal/JulianFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/JulianFields.java Wed May 15 07:48:57 2013 -0700
@@ -81,7 +81,7 @@
* The fields are supported, and can be queried and set if {@code EPOCH_DAY} is available.
* The fields work with all chronologies.
*
- *
*
- *
- * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
- * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
- * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code MONTHS}.
*
- *
- * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
- * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
- * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code MONTHS}.
*
- *
* Implementations must not alter either this object or the specified temporal object.
@@ -353,10 +345,10 @@
//-----------------------------------------------------------------------
/**
- * Calculates the period between this temporal and another temporal in
- * terms of the specified unit.
+ * Calculates the amount of time until another temporal in terms of the specified unit.
*
- * This calculates the period between two temporals in terms of a single unit.
+ * This calculates the amount of time between two temporal objects
+ * of the same type in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified temporal.
* The result will be negative if the end is before the start.
* For example, the period in hours between two temporal objects can be
@@ -385,7 +377,7 @@
* long daysBetween = DAYS.between(start, end);
*
*
- *
@@ -137,7 +137,7 @@
* and it is important not to read too much into them. For example, there
* could be values within the range that are invalid for the field.
*
- *
@@ -127,7 +127,7 @@
* It is recommended to use the second approach, {@code with(TemporalAdjuster)},
* as it is a lot clearer to read in code.
*
- *
* In general, user-written adjusters should be static constants:
- *
- * This calculates the period between two temporals in terms of this unit.
- * The start and end points are supplied as temporal objects and must be
- * of the same type.
+ * This calculates the amount in terms of this unit. The start and end
+ * points are supplied as temporal objects and must be of the same type.
* The result will be negative if the end is before the start.
- * For example, the period in hours between two temporal objects can be
+ * For example, the amount in hours between two temporal objects can be
* calculated using {@code HOURS.between(startTime, endTime)}.
*
* The calculation returns a whole number, representing the number of
* complete units between the two temporals.
- * For example, the period in hours between the times 11:30 and 13:29
+ * For example, the amount in hours between the times 11:30 and 13:29
* will only be one hour as it is one minute short of two hours.
*
* There are two equivalent ways of using this method.
@@ -237,9 +235,9 @@
*
* @param temporal1 the base temporal object, not null
* @param temporal2 the other temporal object, not null
- * @return the period between temporal1 and temporal2 in terms of this unit;
+ * @return the amount of time between temporal1 and temporal2 in terms of this unit;
* positive if temporal2 is later than temporal1, negative if earlier
- * @throws DateTimeException if the period cannot be calculated
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
* @throws ArithmeticException if numeric overflow occurs
*/
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java
--- a/jdk/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
* UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is
* not supported for a Temporal class.
*
- *
* Instances of this class are not tied to a specific field.
*
- *
- * This field is an immutable and thread-safe singleton.
*/
public static final WeekFields ISO = new WeekFields(DayOfWeek.MONDAY, 4);
@@ -211,8 +210,6 @@
*
* Defined as starting on Sunday and with a minimum of 1 day in the month.
* This week definition is in use in the US and other European countries.
- *
- * This field is an immutable and thread-safe singleton.
*/
public static final WeekFields SUNDAY_START = WeekFields.of(DayOfWeek.SUNDAY, 1);
@@ -230,7 +227,7 @@
* In that case, the week is set to the last week of the year
* with the same day-of-week.
*
- * This field is an immutable and thread-safe singleton.
+ * This unit is an immutable and thread-safe singleton.
*/
public static final TemporalUnit WEEK_BASED_YEARS = IsoFields.WEEK_BASED_YEARS;
@@ -247,22 +244,18 @@
* The minimal number of days in the first week.
*/
private final int minimalDays;
-
/**
* The field used to access the computed DayOfWeek.
*/
private transient final TemporalField dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
-
/**
* The field used to access the computed WeekOfMonth.
*/
private transient final TemporalField weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
-
/**
* The field used to access the computed WeekOfYear.
*/
private transient final TemporalField weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
-
/**
* The field that represents the week-of-week-based-year.
*
@@ -271,7 +264,6 @@
* This unit is an immutable and thread-safe singleton.
*/
private transient final TemporalField weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
-
/**
* The field that represents the week-based-year.
*
@@ -281,6 +273,7 @@
*/
private transient final TemporalField weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
+ //-----------------------------------------------------------------------
/**
* Obtains an instance of {@code WeekFields} appropriate for a locale.
*
@@ -359,8 +352,7 @@
try {
return WeekFields.of(firstDayOfWeek, minimalDays);
} catch (IllegalArgumentException iae) {
- throw new InvalidObjectException("Invalid serialized WeekFields: "
- + iae.getMessage());
+ throw new InvalidObjectException("Invalid serialized WeekFields: " + iae.getMessage());
}
}
@@ -394,21 +386,24 @@
//-----------------------------------------------------------------------
/**
- * Returns a field to access the day of week,
- * computed based on this WeekFields.
+ * Returns a field to access the day of week based on this {@code WeekFields}.
*
- * The days of week are numbered from 1 to 7.
- * Day number 1 is the {@link #getFirstDayOfWeek() first day-of-week}.
+ * This is similar to {@link ChronoField#DAY_OF_WEEK} but uses values for
+ * the day-of-week based on this {@code WeekFields}.
+ * The days are numbered from 1 to 7 where the
+ * {@link #getFirstDayOfWeek() first day-of-week} is assigned the value 1.
+ *
+ * For example, if the first day-of-week is Sunday, then that will have the
+ * value 1, with other days ranging from Monday as 2 to Saturday as 7.
*
- * @return the field for day-of-week using this week definition, not null
+ * @return a field providing access to the day-of-week with localized numbering, not null
*/
public TemporalField dayOfWeek() {
return dayOfWeek;
}
/**
- * Returns a field to access the week of month,
- * computed based on this WeekFields.
+ * Returns a field to access the week of month based on this {@code WeekFields}.
*
* This represents the concept of the count of weeks within the month where weeks
* start on a fixed day-of-week, such as Monday.
@@ -426,15 +421,15 @@
* - if the 5th day of the month is a Monday, week two starts on the 5th and the 1st to 4th is in week one
* This field can be used with any calendar system.
- * @return a TemporalField to access the WeekOfMonth, not null
+ *
+ * @return a field providing access to the week-of-month, not null
*/
public TemporalField weekOfMonth() {
return weekOfMonth;
}
/**
- * Returns a field to access the week of year,
- * computed based on this WeekFields.
+ * Returns a field to access the week of year based on this {@code WeekFields}.
*
* This represents the concept of the count of weeks within the year where weeks
* start on a fixed day-of-week, such as Monday.
@@ -452,15 +447,15 @@
* - if the 5th day of the year is a Monday, week two starts on the 5th and the 1st to 4th is in week one
* This field can be used with any calendar system.
- * @return a TemporalField to access the WeekOfYear, not null
+ *
+ * @return a field providing access to the week-of-year, not null
*/
public TemporalField weekOfYear() {
return weekOfYear;
}
/**
- * Returns a field to access the week of a week-based-year,
- * computed based on this WeekFields.
+ * Returns a field to access the week of a week-based-year based on this {@code WeekFields}.
*
* This represents the concept of the count of weeks within the year where weeks
* start on a fixed day-of-week, such as Monday and each week belongs to exactly one year.
@@ -482,15 +477,15 @@
* the 1st to 4th is in week one
* This field can be used with any calendar system.
- * @return a TemporalField to access the week of week-based-year, not null
+ *
+ * @return a field providing access to the week-of-week-based-year, not null
*/
public TemporalField weekOfWeekBasedYear() {
return weekOfWeekBasedYear;
}
/**
- * Returns a field to access the year of a week-based-year,
- * computed based on this WeekFields.
+ * Returns a field to access the year of a week-based-year based on this {@code WeekFields}.
*
* This represents the concept of the year where weeks start on a fixed day-of-week,
* such as Monday and each week belongs to exactly one year.
@@ -504,14 +499,16 @@
* is in the last week of the previous year.
*
* This field can be used with any calendar system.
- * @return a TemporalField to access the year of week-based-year, not null
+ *
+ * @return a field providing access to the week-based-year, not null
*/
public TemporalField weekBasedYear() {
return weekBasedYear;
}
+ //-----------------------------------------------------------------------
/**
- * Checks if this WeekFields is equal to the specified object.
+ * Checks if this {@code WeekFields} is equal to the specified object.
*
* The comparison is based on the entire state of the rules, which is
* the first day-of-week and minimal days.
@@ -531,7 +528,7 @@
}
/**
- * A hash code for these rules.
+ * A hash code for this {@code WeekFields}.
*
* @return a suitable hash code
*/
@@ -542,7 +539,7 @@
//-----------------------------------------------------------------------
/**
- * A string representation of this definition.
+ * A string representation of this {@code WeekFields} instance.
*
* @return the string representation, not null
*/
@@ -957,7 +954,6 @@
/**
* Map the field range to a week range of a week year.
* @param temporal the temporal
- * @param field the field to get the range of
* @return the ValueRange with the range adjusted to weeks.
*/
private ValueRange rangeWeekOfWeekBasedYear(TemporalAccessor temporal) {
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/Ser.java
--- a/jdk/src/share/classes/java/time/zone/Ser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/Ser.java Wed May 15 07:48:57 2013 -0700
@@ -74,7 +74,7 @@
/**
* The shared serialization delegate for this package.
*
- *
* These different rule types can be expressed and queried.
*
- *
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/util/JapaneseImperialCalendar.java
--- a/jdk/src/share/classes/java/util/JapaneseImperialCalendar.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/util/JapaneseImperialCalendar.java Wed May 15 07:48:57 2013 -0700
@@ -249,11 +249,14 @@
CalendarDate transitionDate = eras[i].getSinceDate();
date.setDate(transitionDate.getYear(), BaseCalendar.JANUARY, 1);
long fdd = gcal.getFixedDate(date);
- dayOfYear = Math.min((int)(fdd - fd), dayOfYear);
+ if (fd != fdd) {
+ dayOfYear = Math.min((int)(fd - fdd) + 1, dayOfYear);
+ }
date.setDate(transitionDate.getYear(), BaseCalendar.DECEMBER, 31);
- fdd = gcal.getFixedDate(date) + 1;
- dayOfYear = Math.min((int)(fd - fdd), dayOfYear);
-
+ fdd = gcal.getFixedDate(date);
+ if (fd != fdd) {
+ dayOfYear = Math.min((int)(fdd - fd) + 1, dayOfYear);
+ }
LocalGregorianCalendar.Date lgd = getCalendarDate(fd - 1);
int y = lgd.getYear();
// Unless the first year starts from January 1, the actual
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java
--- a/jdk/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java Wed May 15 07:48:57 2013 -0700
@@ -246,16 +246,16 @@
return false;
}
ldate.setNormalizedYear(era.getSinceDate().getYear() + ldate.getYear() - 1);
- // If it's not the last Era, validate the date.
- if (era != eras[eras.length - 1]) {
- Date tmp = newCalendarDate(date.getZone());
- tmp.setEra(era).setDate(date.getYear(), date.getMonth(), date.getDayOfMonth());
- normalize(tmp);
- if (tmp.getEra() != era) {
- return false;
- }
+ Date tmp = newCalendarDate(date.getZone());
+ tmp.setEra(era).setDate(date.getYear(), date.getMonth(), date.getDayOfMonth());
+ normalize(tmp);
+ if (tmp.getEra() != era) {
+ return false;
}
} else {
+ if (date.getYear() >= eras[0].getSinceDate().getYear()) {
+ return false;
+ }
ldate.setNormalizedYear(ldate.getYear());
}
return super.validate(ldate);
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/test/java/time/tck/java/time/TCKInstant.java
--- a/jdk/test/java/time/tck/java/time/TCKInstant.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKInstant.java Wed May 15 07:48:57 2013 -0700
@@ -370,6 +370,8 @@
{"Z"},
{"1970-01-01T00:00:00"},
{"1970-01-01T00:00:0Z"},
+ {"1970-01-01T00:0:00Z"},
+ {"1970-01-01T0:00:00Z"},
{"1970-01-01T00:00:00.0000000000Z"},
};
}
@@ -2045,60 +2047,64 @@
Object[][] data_toString() {
return new Object[][] {
{Instant.ofEpochSecond(65L, 567), "1970-01-01T00:01:05.000000567Z"},
+ {Instant.ofEpochSecond(65L, 560), "1970-01-01T00:01:05.000000560Z"},
+ {Instant.ofEpochSecond(65L, 560000), "1970-01-01T00:01:05.000560Z"},
+ {Instant.ofEpochSecond(65L, 560000000), "1970-01-01T00:01:05.560Z"},
+
{Instant.ofEpochSecond(1, 0), "1970-01-01T00:00:01Z"},
- {Instant.ofEpochSecond(60, 0), "1970-01-01T00:01Z"},
- {Instant.ofEpochSecond(3600, 0), "1970-01-01T01:00Z"},
+ {Instant.ofEpochSecond(60, 0), "1970-01-01T00:01:00Z"},
+ {Instant.ofEpochSecond(3600, 0), "1970-01-01T01:00:00Z"},
{Instant.ofEpochSecond(-1, 0), "1969-12-31T23:59:59Z"},
- {LocalDateTime.of(0, 1, 2, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-02T00:00Z"},
- {LocalDateTime.of(0, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "0000-01-01T12:30Z"},
+ {LocalDateTime.of(0, 1, 2, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-02T00:00:00Z"},
+ {LocalDateTime.of(0, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "0000-01-01T12:30:00Z"},
{LocalDateTime.of(0, 1, 1, 0, 0, 0, 1).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00.000000001Z"},
- {LocalDateTime.of(0, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-01T00:00Z"},
+ {LocalDateTime.of(0, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00Z"},
{LocalDateTime.of(-1, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-0001-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-1, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-31T12:30Z"},
- {LocalDateTime.of(-1, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-30T12:30Z"},
+ {LocalDateTime.of(-1, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-31T12:30:00Z"},
+ {LocalDateTime.of(-1, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-30T12:30:00Z"},
- {LocalDateTime.of(-9999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-02T12:30Z"},
- {LocalDateTime.of(-9999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-01T12:30Z"},
- {LocalDateTime.of(-9999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-9999-01-01T00:00Z"},
+ {LocalDateTime.of(-9999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-02T12:30:00Z"},
+ {LocalDateTime.of(-9999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-01T12:30:00Z"},
+ {LocalDateTime.of(-9999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-9999-01-01T00:00:00Z"},
{LocalDateTime.of(-10000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-10000-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-10000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-31T12:30Z"},
- {LocalDateTime.of(-10000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-30T12:30Z"},
- {LocalDateTime.of(-15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-15000-12-31T12:30Z"},
+ {LocalDateTime.of(-10000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-31T12:30:00Z"},
+ {LocalDateTime.of(-10000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-30T12:30:00Z"},
+ {LocalDateTime.of(-15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-15000-12-31T12:30:00Z"},
- {LocalDateTime.of(-19999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-02T12:30Z"},
- {LocalDateTime.of(-19999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-01T12:30Z"},
- {LocalDateTime.of(-19999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-19999-01-01T00:00Z"},
+ {LocalDateTime.of(-19999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-02T12:30:00Z"},
+ {LocalDateTime.of(-19999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-01T12:30:00Z"},
+ {LocalDateTime.of(-19999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-19999-01-01T00:00:00Z"},
{LocalDateTime.of(-20000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-20000-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-20000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-31T12:30Z"},
- {LocalDateTime.of(-20000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-30T12:30Z"},
- {LocalDateTime.of(-25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-25000-12-31T12:30Z"},
+ {LocalDateTime.of(-20000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-31T12:30:00Z"},
+ {LocalDateTime.of(-20000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-30T12:30:00Z"},
+ {LocalDateTime.of(-25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-25000-12-31T12:30:00Z"},
- {LocalDateTime.of(9999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-30T12:30Z"},
- {LocalDateTime.of(9999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-31T12:30Z"},
+ {LocalDateTime.of(9999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-30T12:30:00Z"},
+ {LocalDateTime.of(9999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-31T12:30:00Z"},
{LocalDateTime.of(9999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "9999-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(10000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+10000-01-01T00:00Z"},
- {LocalDateTime.of(10000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-01T12:30Z"},
- {LocalDateTime.of(10000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-02T12:30Z"},
- {LocalDateTime.of(15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+15000-12-31T12:30Z"},
+ {LocalDateTime.of(10000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+10000-01-01T00:00:00Z"},
+ {LocalDateTime.of(10000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-01T12:30:00Z"},
+ {LocalDateTime.of(10000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-02T12:30:00Z"},
+ {LocalDateTime.of(15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+15000-12-31T12:30:00Z"},
- {LocalDateTime.of(19999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-30T12:30Z"},
- {LocalDateTime.of(19999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-31T12:30Z"},
+ {LocalDateTime.of(19999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-30T12:30:00Z"},
+ {LocalDateTime.of(19999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-31T12:30:00Z"},
{LocalDateTime.of(19999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "+19999-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(20000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+20000-01-01T00:00Z"},
- {LocalDateTime.of(20000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-01T12:30Z"},
- {LocalDateTime.of(20000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-02T12:30Z"},
- {LocalDateTime.of(25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+25000-12-31T12:30Z"},
+ {LocalDateTime.of(20000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+20000-01-01T00:00:00Z"},
+ {LocalDateTime.of(20000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-01T12:30:00Z"},
+ {LocalDateTime.of(20000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-02T12:30:00Z"},
+ {LocalDateTime.of(25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+25000-12-31T12:30:00Z"},
- {LocalDateTime.of(-999_999_999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC).minus(1, DAYS), "-1000000000-12-31T12:30Z"},
- {LocalDateTime.of(999_999_999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC).plus(1, DAYS), "+1000000000-01-01T12:30Z"},
+ {LocalDateTime.of(-999_999_999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC).minus(1, DAYS), "-1000000000-12-31T12:30:00Z"},
+ {LocalDateTime.of(999_999_999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC).plus(1, DAYS), "+1000000000-01-01T12:30:00Z"},
- {Instant.MIN, "-1000000000-01-01T00:00Z"},
+ {Instant.MIN, "-1000000000-01-01T00:00:00Z"},
{Instant.MAX, "+1000000000-12-31T23:59:59.999999999Z"},
};
}
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/test/java/time/tck/java/time/TCKLocalTime.java
--- a/jdk/test/java/time/tck/java/time/TCKLocalTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKLocalTime.java Wed May 15 07:48:57 2013 -0700
@@ -142,7 +142,7 @@
private static final TemporalUnit[] INVALID_UNITS;
static {
- EnumSetSpecification for implementors
+ * Resolving
+ * Parsing is implemented as a two-phase operation.
+ * First, the text is parsed using the layout defined by the formatter, producing
+ * a {@code Map} of field to value, a {@code ZoneId} and a {@code Chronology}.
+ * Second, the parsed data is resolved, by validating, combining and
+ * simplifying the various fields into more useful ones.
+ *
+ *
+ *
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -435,7 +494,7 @@
/**
* The symbols to use for formatting, not null.
*/
- private final DateTimeFormatSymbols symbols;
+ private final DecimalStyle decimalStyle;
/**
* The resolver style to use, not null.
*/
@@ -1040,6 +1099,11 @@
*
+ *
+ *
+ * Text to parse Parsed object Excess days
+ * "2012-12-03T00:00" LocalDateTime.of(2012, 12, 3, 0, 0) ZERO
+ * "2012-12-03T24:00" LocalDateTime.of(2012, 12, 4, 0, 0) ZERO
+ * "00:00" LocalTime.of(0, 0) ZERO
+ * "24:00" LocalTime.of(0, 0) Period.ofDays(1)
+ *
+ * The query can be used as follows:
+ *
+ * TemporalAccessor parsed = formatter.parse(str);
+ * LocalTime time = parsed.query(LocalTime::from);
+ * Period extraDays = parsed.query(DateTimeFormatter.parsedExcessDays());
+ *
+ */
+ public static final TemporalQuery
+ * TemporalAccessor parsed = formatter.parse(str);
+ * Instant instant = parsed.query(Instant::from);
+ * if (parsed.query(DateTimeFormatter.parsedLeapSecond())) {
+ * // validate leap-second is correct and apply correct smoothing
+ * }
+ *
+ */
+ public static final TemporalQuerySpecification for implementors
+ * @implSpec
* This class is a mutable builder intended for use from a single thread.
*
* @since 1.8
@@ -187,6 +188,44 @@
private int valueParserIndex = -1;
/**
+ * Gets the formatting pattern for date and time styles for a locale and chronology.
+ * The locale and chronology are used to lookup the locale specific format
+ * for the requested dateStyle and/or timeStyle.
+ *
+ * @param dateStyle the FormatStyle for the date
+ * @param timeStyle the FormatStyle for the time
+ * @param chrono the Chronology, non-null
+ * @param locale the locale, non-null
+ * @return the locale and Chronology specific formatting pattern
+ * @throws IllegalArgumentException if both dateStyle and timeStyle are null
+ */
+ public static String getLocalizedDateTimePattern(FormatStyle dateStyle, FormatStyle timeStyle,
+ Chronology chrono, Locale locale) {
+ Objects.requireNonNull(locale, "locale");
+ Objects.requireNonNull(chrono, "chrono");
+ if (dateStyle == null && timeStyle == null) {
+ throw new IllegalArgumentException("Either dateStyle or timeStyle must be non-null");
+ }
+ LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased().getLocaleResources(locale);
+ String pattern = lr.getJavaTimeDateTimePattern(
+ convertStyle(timeStyle), convertStyle(dateStyle), chrono.getCalendarType());
+ return pattern;
+ }
+
+ /**
+ * Converts the given FormatStyle to the java.text.DateFormat style.
+ *
+ * @param style the FormatStyle style
+ * @return the int style, or -1 if style is null, indicating un-required
+ */
+ private static int convertStyle(FormatStyle style) {
+ if (style == null) {
+ return -1;
+ }
+ return style.ordinal(); // indices happen to align
+ }
+
+ /**
* Constructs a new instance of the builder.
*/
public DateTimeFormatterBuilder() {
@@ -344,7 +383,7 @@
*/
public DateTimeFormatterBuilder appendValue(TemporalField field) {
Objects.requireNonNull(field, "field");
- active.valueParserIndex = appendInternal(new NumberPrinterParser(field, 1, 19, SignStyle.NORMAL));
+ appendValue(new NumberPrinterParser(field, 1, 19, SignStyle.NORMAL));
return this;
}
@@ -360,15 +399,15 @@
* If the value of the field is negative then an exception is thrown during formatting.
* Specification for implementors
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Specification for implementors
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard parsing as a new instance of this class
* is automatically created for each parse and parsing is single-threaded
@@ -118,9 +119,13 @@
/**
* Creates a copy of this context.
+ * This retains the case sensitive and strict flags.
*/
DateTimeParseContext copy() {
- return new DateTimeParseContext(formatter);
+ DateTimeParseContext newContext = new DateTimeParseContext(formatter);
+ newContext.caseSensitive = caseSensitive;
+ newContext.strict = strict;
+ return newContext;
}
//-----------------------------------------------------------------------
@@ -128,7 +133,7 @@
* Gets the locale.
* Specification for implementors
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DateTimePrintContext.java
--- a/jdk/src/share/classes/java/time/format/DateTimePrintContext.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimePrintContext.java Wed May 15 07:48:57 2013 -0700
@@ -85,7 +85,7 @@
* Specification for implementors
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard printing as the framework creates
* a new instance of the class for each format and printing is single-threaded.
@@ -234,7 +234,7 @@
* Gets the locale.
* Specification for implementors
+ * @implSpec
* Implementations must be thread-safe.
* Implementations should cache the textual information.
*
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/DecimalStyle.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/time/format/DecimalStyle.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package java.time.format;
+
+import java.text.DecimalFormatSymbols;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * Localized decimal style used in date and time formatting.
+ * Specification for implementors
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/Parsed.java
--- a/jdk/src/share/classes/java/time/format/Parsed.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/Parsed.java Wed May 15 07:48:57 2013 -0700
@@ -80,6 +80,7 @@
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalTime;
+import java.time.Period;
import java.time.ZoneId;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.Chronology;
@@ -105,7 +106,7 @@
* Once parsing is completed, this class can be used as the resultant {@code TemporalAccessor}.
* In most cases, it is only exposed once the fields have been resolved.
*
- * Specification for implementors
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard parsing as a new instance of this class
* is automatically created for each parse and parsing is single-threaded
@@ -128,6 +129,10 @@
*/
Chronology chrono;
/**
+ * Whether a leap-second is parsed.
+ */
+ boolean leapSecond;
+ /**
* The effective chronology.
*/
Chronology effectiveChrono;
@@ -143,6 +148,10 @@
* The resolved time.
*/
private LocalTime time;
+ /**
+ * The excess period from time-only parsing.
+ */
+ Period excessDays = Period.ZERO;
/**
* Creates an instance.
@@ -159,6 +168,7 @@
cloned.fieldValues.putAll(this.fieldValues);
cloned.zone = this.zone;
cloned.chrono = this.chrono;
+ cloned.leapSecond = this.leapSecond;
return cloned;
}
@@ -232,6 +242,7 @@
resolveFields();
resolveTimeLenient();
crossCheck();
+ resolvePeriod();
return this;
}
@@ -308,36 +319,72 @@
private void resolveTimeFields() {
// simplify fields
if (fieldValues.containsKey(CLOCK_HOUR_OF_DAY)) {
+ // lenient allows anything, smart allows 0-24, strict allows 1-24
long ch = fieldValues.remove(CLOCK_HOUR_OF_DAY);
+ if (resolverStyle == ResolverStyle.STRICT || (resolverStyle == ResolverStyle.SMART && ch != 0)) {
+ CLOCK_HOUR_OF_DAY.checkValidValue(ch);
+ }
updateCheckConflict(CLOCK_HOUR_OF_DAY, HOUR_OF_DAY, ch == 24 ? 0 : ch);
}
if (fieldValues.containsKey(CLOCK_HOUR_OF_AMPM)) {
+ // lenient allows anything, smart allows 0-12, strict allows 1-12
long ch = fieldValues.remove(CLOCK_HOUR_OF_AMPM);
+ if (resolverStyle == ResolverStyle.STRICT || (resolverStyle == ResolverStyle.SMART && ch != 0)) {
+ CLOCK_HOUR_OF_AMPM.checkValidValue(ch);
+ }
updateCheckConflict(CLOCK_HOUR_OF_AMPM, HOUR_OF_AMPM, ch == 12 ? 0 : ch);
}
if (fieldValues.containsKey(AMPM_OF_DAY) && fieldValues.containsKey(HOUR_OF_AMPM)) {
long ap = fieldValues.remove(AMPM_OF_DAY);
long hap = fieldValues.remove(HOUR_OF_AMPM);
- updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, ap * 12 + hap);
+ if (resolverStyle == ResolverStyle.LENIENT) {
+ updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, Math.addExact(Math.multiplyExact(ap, 12), hap));
+ } else { // STRICT or SMART
+ AMPM_OF_DAY.checkValidValue(ap);
+ HOUR_OF_AMPM.checkValidValue(ap);
+ updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, ap * 12 + hap);
+ }
+ }
+ if (fieldValues.containsKey(NANO_OF_DAY)) {
+ long nod = fieldValues.remove(NANO_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ NANO_OF_DAY.checkValidValue(nod);
+ }
+ updateCheckConflict(NANO_OF_DAY, HOUR_OF_DAY, nod / 3600_000_000_000L);
+ updateCheckConflict(NANO_OF_DAY, MINUTE_OF_HOUR, (nod / 60_000_000_000L) % 60);
+ updateCheckConflict(NANO_OF_DAY, SECOND_OF_MINUTE, (nod / 1_000_000_000L) % 60);
+ updateCheckConflict(NANO_OF_DAY, NANO_OF_SECOND, nod % 1_000_000_000L);
}
if (fieldValues.containsKey(MICRO_OF_DAY)) {
long cod = fieldValues.remove(MICRO_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MICRO_OF_DAY.checkValidValue(cod);
+ }
updateCheckConflict(MICRO_OF_DAY, SECOND_OF_DAY, cod / 1_000_000L);
updateCheckConflict(MICRO_OF_DAY, MICRO_OF_SECOND, cod % 1_000_000L);
}
if (fieldValues.containsKey(MILLI_OF_DAY)) {
long lod = fieldValues.remove(MILLI_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MILLI_OF_DAY.checkValidValue(lod);
+ }
updateCheckConflict(MILLI_OF_DAY, SECOND_OF_DAY, lod / 1_000);
updateCheckConflict(MILLI_OF_DAY, MILLI_OF_SECOND, lod % 1_000);
}
if (fieldValues.containsKey(SECOND_OF_DAY)) {
long sod = fieldValues.remove(SECOND_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ SECOND_OF_DAY.checkValidValue(sod);
+ }
updateCheckConflict(SECOND_OF_DAY, HOUR_OF_DAY, sod / 3600);
updateCheckConflict(SECOND_OF_DAY, MINUTE_OF_HOUR, (sod / 60) % 60);
updateCheckConflict(SECOND_OF_DAY, SECOND_OF_MINUTE, sod % 60);
}
if (fieldValues.containsKey(MINUTE_OF_DAY)) {
long mod = fieldValues.remove(MINUTE_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MINUTE_OF_DAY.checkValidValue(mod);
+ }
updateCheckConflict(MINUTE_OF_DAY, HOUR_OF_DAY, mod / 60);
updateCheckConflict(MINUTE_OF_DAY, MINUTE_OF_HOUR, mod % 60);
}
@@ -345,29 +392,34 @@
// combine partial second fields strictly, leaving lenient expansion to later
if (fieldValues.containsKey(NANO_OF_SECOND)) {
long nos = fieldValues.get(NANO_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ NANO_OF_SECOND.checkValidValue(nos);
+ }
if (fieldValues.containsKey(MICRO_OF_SECOND)) {
long cos = fieldValues.remove(MICRO_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MICRO_OF_SECOND.checkValidValue(cos);
+ }
nos = cos * 1000 + (nos % 1000);
updateCheckConflict(MICRO_OF_SECOND, NANO_OF_SECOND, nos);
}
if (fieldValues.containsKey(MILLI_OF_SECOND)) {
long los = fieldValues.remove(MILLI_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MILLI_OF_SECOND.checkValidValue(los);
+ }
updateCheckConflict(MILLI_OF_SECOND, NANO_OF_SECOND, los * 1_000_000L + (nos % 1_000_000L));
}
}
- // convert to time if possible
- if (fieldValues.containsKey(NANO_OF_DAY)) {
- long nod = fieldValues.remove(NANO_OF_DAY);
- updateCheckConflict(LocalTime.ofNanoOfDay(nod));
- }
+ // convert to time if all four fields available (optimization)
if (fieldValues.containsKey(HOUR_OF_DAY) && fieldValues.containsKey(MINUTE_OF_HOUR) &&
fieldValues.containsKey(SECOND_OF_MINUTE) && fieldValues.containsKey(NANO_OF_SECOND)) {
- int hodVal = HOUR_OF_DAY.checkValidIntValue(fieldValues.remove(HOUR_OF_DAY));
- int mohVal = MINUTE_OF_HOUR.checkValidIntValue(fieldValues.remove(MINUTE_OF_HOUR));
- int somVal = SECOND_OF_MINUTE.checkValidIntValue(fieldValues.remove(SECOND_OF_MINUTE));
- int nosVal = NANO_OF_SECOND.checkValidIntValue(fieldValues.remove(NANO_OF_SECOND));
- updateCheckConflict(LocalTime.of(hodVal, mohVal, somVal, nosVal));
+ long hod = fieldValues.remove(HOUR_OF_DAY);
+ long moh = fieldValues.remove(MINUTE_OF_HOUR);
+ long som = fieldValues.remove(SECOND_OF_MINUTE);
+ long nos = fieldValues.remove(NANO_OF_SECOND);
+ resolveTime(hod, moh, som, nos);
}
}
@@ -377,7 +429,7 @@
// which would break updateCheckConflict(field)
if (time == null) {
- // can only get here if NANO_OF_SECOND not present
+ // NANO_OF_SECOND merged with MILLI/MICRO above
if (fieldValues.containsKey(MILLI_OF_SECOND)) {
long los = fieldValues.remove(MILLI_OF_SECOND);
if (fieldValues.containsKey(MICRO_OF_SECOND)) {
@@ -395,43 +447,87 @@
long cos = fieldValues.remove(MICRO_OF_SECOND);
fieldValues.put(NANO_OF_SECOND, cos * 1_000L);
}
- }
- // merge hour/minute/second/nano leniently
- Long hod = fieldValues.get(HOUR_OF_DAY);
- if (hod != null) {
- int hodVal = HOUR_OF_DAY.checkValidIntValue(hod);
- Long moh = fieldValues.get(MINUTE_OF_HOUR);
- Long som = fieldValues.get(SECOND_OF_MINUTE);
- Long nos = fieldValues.get(NANO_OF_SECOND);
+ // merge hour/minute/second/nano leniently
+ Long hod = fieldValues.get(HOUR_OF_DAY);
+ if (hod != null) {
+ Long moh = fieldValues.get(MINUTE_OF_HOUR);
+ Long som = fieldValues.get(SECOND_OF_MINUTE);
+ Long nos = fieldValues.get(NANO_OF_SECOND);
- // check for invalid combinations that cannot be defaulted
- if (time == null) {
+ // check for invalid combinations that cannot be defaulted
if ((moh == null && (som != null || nos != null)) ||
(moh != null && som == null && nos != null)) {
return;
}
- }
- // default as necessary and build time
- int mohVal = (moh != null ? MINUTE_OF_HOUR.checkValidIntValue(moh) : (time != null ? time.getMinute() : 0));
- int somVal = (som != null ? SECOND_OF_MINUTE.checkValidIntValue(som) : (time != null ? time.getSecond() : 0));
- int nosVal = (nos != null ? NANO_OF_SECOND.checkValidIntValue(nos) : (time != null ? time.getNano() : 0));
- updateCheckConflict(LocalTime.of(hodVal, mohVal, somVal, nosVal));
- fieldValues.remove(HOUR_OF_DAY);
- fieldValues.remove(MINUTE_OF_HOUR);
- fieldValues.remove(SECOND_OF_MINUTE);
- fieldValues.remove(NANO_OF_SECOND);
+ // default as necessary and build time
+ long mohVal = (moh != null ? moh : 0);
+ long somVal = (som != null ? som : 0);
+ long nosVal = (nos != null ? nos : 0);
+ resolveTime(hod, mohVal, somVal, nosVal);
+ fieldValues.remove(HOUR_OF_DAY);
+ fieldValues.remove(MINUTE_OF_HOUR);
+ fieldValues.remove(SECOND_OF_MINUTE);
+ fieldValues.remove(NANO_OF_SECOND);
+ }
+ }
+
+ // validate remaining
+ if (resolverStyle != ResolverStyle.LENIENT && fieldValues.size() > 0) {
+ for (EntrySpecification for implementors
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
@@ -96,10 +96,9 @@
* behavior. Individual fields will interpret this differently.
* Specification for implementors
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/TextStyle.java
--- a/jdk/src/share/classes/java/time/format/TextStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/TextStyle.java Wed May 15 07:48:57 2013 -0700
@@ -80,7 +80,7 @@
* For example, the word used for a month when used alone in a date picker is different
* to the word used for month in association with a day and year in a date.
*
- * Specification for implementors
+ * @implSpec
* This is immutable and thread-safe enum.
*/
public enum TextStyle {
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/format/package-info.java
--- a/jdk/src/share/classes/java/time/format/package-info.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/package-info.java Wed May 15 07:48:57 2013 -0700
@@ -76,7 +76,7 @@
* Localization occurs by calling
* {@link java.time.format.DateTimeFormatter#withLocale(java.util.Locale) withLocale(Locale)}
* on the formatter. Further customization is possible using
- * {@link java.time.format.DateTimeFormatSymbols DateTimeFormatSymbols}.
+ * {@link java.time.format.DecimalStyle DecimalStyle}.
* Package specification
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/ChronoField.java
--- a/jdk/src/share/classes/java/time/temporal/ChronoField.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ChronoField.java Wed May 15 07:48:57 2013 -0700
@@ -93,7 +93,7 @@
* just with slightly different rules.
* The documentation of each field explains how it operates.
*
- * Specification for implementors
+ * @implSpec
* This is a final, immutable and thread-safe enum.
*
* @since 1.8
@@ -115,6 +115,10 @@
* object stores, using integer division to remove excess precision.
* For example, if the {@code TemporalAccessor} stores time to millisecond precision,
* then the nano-of-second must be divided by 1,000,000 before replacing the milli-of-second.
+ * Specification for implementors
+ * @implSpec
* This is a final, immutable and thread-safe enum.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/IsoFields.java
--- a/jdk/src/share/classes/java/time/temporal/IsoFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/IsoFields.java Wed May 15 07:48:57 2013 -0700
@@ -146,7 +146,7 @@
* 2009-01-05 Monday Week 2 of week-based-year 2009 Specification for implementors
+ * @implSpec
* Specification for implementors
+ * @implSpec
* This is an immutable and thread-safe class.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/Temporal.java
--- a/jdk/src/share/classes/java/time/temporal/Temporal.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/Temporal.java Wed May 15 07:48:57 2013 -0700
@@ -119,7 +119,7 @@
* days to months.
* Specification for implementors
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
* All implementations must be {@link Comparable}.
@@ -146,7 +146,7 @@
* date = date.with(next(WEDNESDAY)); // static import from Adjusters and DayOfWeek
*
*
- * Specification for implementors
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -177,7 +177,7 @@
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
*
- * Specification for implementors
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the adjustment must be performed.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -217,7 +217,7 @@
* Note that calling {@code plus} followed by {@code minus} is not guaranteed to
* return the same date-time.
*
- * Specification for implementors
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -247,12 +247,8 @@
* a date representing the 31st January, then adding one month would be unclear.
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
- * Specification for implementors
+ * @implSpec
* Implementations must check and handle all units defined in {@link ChronoUnit}.
* If the unit is supported, then the addition must be performed.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -292,7 +288,7 @@
* Note that calling {@code plus} followed by {@code minus} is not guaranteed to
* return the same date-time.
*
- * Specification for implementors
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -322,12 +318,8 @@
* a date representing the 31st March, then subtracting one month would be unclear.
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
- * Specification for implementors
+ * @implSpec
* Implementations must behave in a manor equivalent to the default method behavior.
* Specification for implementors
+ * @implSpec
* Implementations must begin by checking to ensure that the input temporal
* object is of the same observable type as the implementation.
* They must then perform the calculation for all instances of {@link ChronoUnit}.
@@ -410,11 +402,11 @@
* Neither this object, nor the specified temporal, may be altered.
*
* @param endTemporal the end temporal, of the same type as this object, not null
- * @param unit the unit to measure the period in, not null
- * @return the period between this temporal object and the specified one in terms of
- * the unit; positive if the specified object is later than this one, negative if
- * it is earlier than this one
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this temporal object and the specified one
+ * in terms of the unit; positive if the specified object is later than this one,
+ * negative if it is earlier than this one
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalAccessor.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalAccessor.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAccessor.java Wed May 15 07:48:57 2013 -0700
@@ -94,7 +94,7 @@
* of this interface may be in calendar systems other than ISO.
* See {@link java.time.chrono.ChronoLocalDate} for a fuller discussion of the issues.
*
- * Specification for implementors
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -109,7 +109,7 @@
* If false, then calling the {@link #range(TemporalField) range} and {@link #get(TemporalField) get}
* methods will throw an exception.
*
- * Specification for implementors
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then true is returned, otherwise false
* Specification for implementors
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the range of the field must be returned.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -183,7 +183,7 @@
* If the date-time cannot return the value, because the field is unsupported or for
* some other reason, an exception will be thrown.
*
- * Specification for implementors
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported and has an {@code int} range, then the value of
* the field must be returned.
@@ -231,7 +231,7 @@
* If the date-time cannot return the value, because the field is unsupported or for
* some other reason, an exception will be thrown.
*
- * Specification for implementors
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the value of the field must be returned.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -265,7 +265,7 @@
* {@code LocalDate::from} and {@code ZoneId::from}.
* Additional implementations are provided as static methods on {@link TemporalQuery}.
*
- * Specification for implementors
+ * @implSpec
* The default implementation must behave equivalent to this code:
*
* if (query == TemporalQuery.zoneId() ||
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalAdjuster.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalAdjuster.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAdjuster.java Wed May 15 07:48:57 2013 -0700
@@ -97,7 +97,7 @@
* Specification for implementors
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
* Specification for implementors
+ * @implSpec
* The implementation must take the input object and adjust it.
* The implementation defines the logic of the adjustment and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
@@ -162,10 +162,10 @@
* This is provided for convenience to make user-written adjusters simpler.
*
+ *
*
* @param dateBasedAdjuster the date-based adjuster, not null
* @return the temporal adjuster wrapping on the date adjuster, not null
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalAmount.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalAmount.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAmount.java Wed May 15 07:48:57 2013 -0700
@@ -90,7 +90,7 @@
* used in application code. Instead, applications should create and pass
* around instances of concrete types, such as {@code Period} and {@code Duration}.
*
- * {@code
* static TemporalAdjuster TWO_DAYS_LATER = TemporalAdjuster.ofDateAdjuster(
* date -> date.plusDays(2));
- *
+ * }Specification for implementors
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -104,7 +104,7 @@
* value of the {@code TemporalAmount}. A value must be returned
* for each unit listed in {@code getUnits}.
*
- * Specification for implementors
+ * @implSpec
* Implementations may declare support for units not listed by {@link #getUnits()}.
* Typically, the implementation would define additional units
* as conversions for the convenience of developers.
@@ -124,7 +124,7 @@
* The units are ordered from longest duration to the shortest duration
* of the unit.
*
- * Specification for implementors
+ * @implSpec
* The list of units completely and uniquely represents the
* state of the object without omissions, overlaps or duplication.
* The units are in order from longest duration to shortest.
@@ -150,7 +150,7 @@
* It is recommended to use the second approach, {@code plus(TemporalAmount)},
* as it is a lot clearer to read in code.
*
- * Specification for implementors
+ * @implSpec
* The implementation must take the input object and add to it.
* The implementation defines the logic of the addition and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
@@ -192,7 +192,7 @@
* It is recommended to use the second approach, {@code minus(TemporalAmount)},
* as it is a lot clearer to read in code.
*
- * Specification for implementors
+ * @implSpec
* The implementation must take the input object and subtract from it.
* The implementation defines the logic of the subtraction and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalField.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalField.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalField.java Wed May 15 07:48:57 2013 -0700
@@ -82,7 +82,7 @@
* If it is, then the date-time must handle it.
* Otherwise, the method call is re-dispatched to the matching method in this interface.
*
- * Specification for implementors
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Implementations should be {@code Serializable} where possible.
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalQuery.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalQuery.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalQuery.java Wed May 15 07:48:57 2013 -0700
@@ -96,7 +96,7 @@
* {@code LocalDate::from} and {@code ZoneId::from}.
* Additional common implementations are provided on this interface as static methods.
*
- * Specification for implementors
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -124,7 +124,7 @@
* It is recommended to use the second approach, {@code query(TemporalQuery)},
* as it is a lot clearer to read in code.
*
- * Specification for implementors
+ * @implSpec
* The implementation must take the input object and query it.
* The implementation defines the logic of the query and is responsible for
* documenting that logic.
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/TemporalUnit.java
--- a/jdk/src/share/classes/java/time/temporal/TemporalUnit.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalUnit.java Wed May 15 07:48:57 2013 -0700
@@ -83,7 +83,7 @@
* If it is, then the date-time must handle it.
* Otherwise, the method call is re-dispatched to the matching method in this interface.
*
- * Specification for implementors
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* It is recommended to use an enum where possible.
@@ -197,19 +197,17 @@
//-----------------------------------------------------------------------
/**
- * Calculates the period in terms of this unit between two temporal objects
- * of the same type.
+ * Calculates the amount of time between two temporal objects.
* Specification for implementors
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/ValueRange.java
--- a/jdk/src/share/classes/java/time/temporal/ValueRange.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ValueRange.java Wed May 15 07:48:57 2013 -0700
@@ -79,7 +79,7 @@
* Specification for implementors
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/temporal/WeekFields.java
--- a/jdk/src/share/classes/java/time/temporal/WeekFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/WeekFields.java Wed May 15 07:48:57 2013 -0700
@@ -170,7 +170,8 @@
* 2009-01-05 Monday
* Week 2 of 2009 Week 1 of 2009 Specification for implementors
+ *
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -200,8 +201,6 @@
* Note that the first week may start in the previous calendar year.
* Note also that the first few days of a calendar year may be in the
* week-based-year corresponding to the previous calendar year.
- *
*
*
* Implementation notes
+ * @implNote
* This class is mutable and should be created once per serialization.
*
* @serial include
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/ZoneOffsetTransition.java
--- a/jdk/src/share/classes/java/time/zone/ZoneOffsetTransition.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneOffsetTransition.java Wed May 15 07:48:57 2013 -0700
@@ -89,7 +89,7 @@
* An example would be when the offset changes from {@code +04:00} to {@code +03:00}.
* This might be described as 'the clocks will move back one hour tonight at 2am'.
*
- * Specification for implementors
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java
--- a/jdk/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java Wed May 15 07:48:57 2013 -0700
@@ -90,7 +90,7 @@
* Specification for implementors
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/ZoneRules.java
--- a/jdk/src/share/classes/java/time/zone/ZoneRules.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRules.java Wed May 15 07:48:57 2013 -0700
@@ -100,7 +100,7 @@
* Applications should treat the data provided as representing the best information
* available to the implementation of this rule.
*
- * Specification for implementors
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/ZoneRulesException.java
--- a/jdk/src/share/classes/java/time/zone/ZoneRulesException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRulesException.java Wed May 15 07:48:57 2013 -0700
@@ -64,7 +64,7 @@
* This exception is used to indicate a problems with the configured
* time-zone rules.
*
- * Specification for implementors
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
diff -r 35cd9b3a98ff -r 8c100beabcc0 jdk/src/share/classes/java/time/zone/ZoneRulesProvider.java
--- a/jdk/src/share/classes/java/time/zone/ZoneRulesProvider.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRulesProvider.java Wed May 15 07:48:57 2013 -0700
@@ -111,7 +111,7 @@
* Each provider will provide the latest rules for each zone ID, but they
* may also provide the history of how the rules changed.
*
- * Specification for implementors
+ * @implSpec
* This interface is a service provider that can be called by multiple threads.
* Implementations must be immutable and thread-safe.
*