stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8204444: java.time cleanup

Browse Source 
Reviewed-by: scolebourne, rriggs
This commit is contained in:
Martin Buchholz 2018-06-08 09:36:10 -07:00
parent 749c4a054b
commit 170d8a7fae
12 changed files with 62 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/java.base/share/classes/java/time/Clock.java
View File

@ -586,7 +586,7 @@ public abstract class Clock {
* This is typically used for testing.
*/
static final class FixedClock extends Clock implements Serializable {
private static final long serialVersionUID = 7430389292664866958L;
private static final long serialVersionUID = 7430389292664866958L;
private final Instant instant;
private final ZoneId zone;
@ -636,7 +636,7 @@ public abstract class Clock {
* Implementation of a clock that adds an offset to an underlying clock.
*/
static final class OffsetClock extends Clock implements Serializable {
private static final long serialVersionUID = 2007484719125426256L;
private static final long serialVersionUID = 2007484719125426256L;
private final Clock baseClock;
private final Duration offset;

12
src/java.base/share/classes/java/time/Duration.java
View File

@ -231,7 +231,7 @@ public final class Duration
* This method allows an arbitrary number of nanoseconds to be passed in.
* The factory will alter the values of the second and nanosecond in order
* to ensure that the stored nanosecond is in the range 0 to 999,999,999.
* For example, the following will result in the exactly the same duration:
* For example, the following will result in exactly the same duration:
* <pre>
* Duration.ofSeconds(3, 1);
* Duration.ofSeconds(4, -999_999_999);
@ -1357,12 +1357,14 @@ public final class Duration
* Truncating the duration returns a copy of the original with conceptual fields
* smaller than the specified unit set to zero.
* For example, truncating with the {@link ChronoUnit#MINUTES MINUTES} unit will
* round down to the nearest minute, setting the seconds and nanoseconds to zero.
* round down towards zero to the nearest minute, setting the seconds and
* nanoseconds to zero.
* <p>
* The unit must have a {@linkplain TemporalUnit#getDuration() duration}
* that divides into the length of a standard day without remainder.
* This includes all supplied time units on {@link ChronoUnit} and
* {@link ChronoUnit#DAYS DAYS}. Other ChronoUnits throw an exception.
* This includes all
* {@linkplain ChronoUnit#isTimeBased() time-based units on {@code ChronoUnit}}
* and {@link ChronoUnit#DAYS DAYS}. Other ChronoUnits throw an exception.
* <p>
* This instance is immutable and unaffected by this method call.
*
@ -1388,7 +1390,7 @@ public final class Duration
throw new UnsupportedTemporalTypeException("Unit must divide into a standard day without remainder");
}
long nod = (seconds % LocalTime.SECONDS_PER_DAY) * LocalTime.NANOS_PER_SECOND + nanos;
long result = (nod / dur) * dur ;
long result = (nod / dur) * dur;
return plusNanos(result - nod);
}

4
src/java.base/share/classes/java/time/Instant.java
View File

@ -311,7 +311,7 @@ public final class Instant
* This method allows an arbitrary number of nanoseconds to be passed in.
* The factory will alter the values of the second and nanosecond in order
* to ensure that the stored nanosecond is in the range 0 to 999,999,999.
* For example, the following will result in the exactly the same instant:
* For example, the following will result in exactly the same instant:
* <pre>
* Instant.ofEpochSecond(3, 1);
* Instant.ofEpochSecond(4, -999_999_999);
@ -757,7 +757,7 @@ public final class Instant
throw new UnsupportedTemporalTypeException("Unit must divide into a standard day without remainder");
}
long nod = (seconds % LocalTime.SECONDS_PER_DAY) * LocalTime.NANOS_PER_SECOND + nanos;
long result = Math.floorDiv(nod, dur) * dur ;
long result = Math.floorDiv(nod, dur) * dur;
return plusNanos(result - nod);
}

16
src/java.base/share/classes/java/time/LocalTime.java
View File

@ -356,14 +356,14 @@ public final class LocalTime
* @return the local time, not null
* @since 9
*/
public static LocalTime ofInstant(Instant instant, ZoneId zone) {
Objects.requireNonNull(instant, "instant");
Objects.requireNonNull(zone, "zone");
ZoneOffset offset = zone.getRules().getOffset(instant);
long localSecond = instant.getEpochSecond() + offset.getTotalSeconds();
int secsOfDay = Math.floorMod(localSecond, SECONDS_PER_DAY);
return ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + instant.getNano());
}
public static LocalTime ofInstant(Instant instant, ZoneId zone) {
Objects.requireNonNull(instant, "instant");
Objects.requireNonNull(zone, "zone");
ZoneOffset offset = zone.getRules().getOffset(instant);
long localSecond = instant.getEpochSecond() + offset.getTotalSeconds();
int secsOfDay = Math.floorMod(localSecond, SECONDS_PER_DAY);
return ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + instant.getNano());
}
//-----------------------------------------------------------------------
/**

2
src/java.base/share/classes/java/time/chrono/ChronoLocalDateImpl.java
View File

@ -110,7 +110,7 @@ import java.util.Objects;
* int year = date.get(ChronoField.YEAR);
* System.out.printf(" Today is %s %s %d-%s-%d%n", date.getChronology().getID(),
* dow, day, month, year);
*
* // Print today's date and the last day of the year
* ChronoLocalDate now1 = Chronology.of("Hijrah").dateNow();
* ChronoLocalDate first = now1.with(ChronoField.DAY_OF_MONTH, 1)

2
src/java.base/share/classes/java/time/chrono/ChronoLocalDateTime.java
View File

@ -201,7 +201,7 @@ public interface ChronoLocalDateTime<D extends ChronoLocalDate>
*
* @return the date part of this date-time, not null
*/
D toLocalDate() ;
D toLocalDate();
/**
* Gets the local time part of this date-time.

8
src/java.base/share/classes/java/time/chrono/Chronology.java
View File

@ -736,8 +736,8 @@ public interface Chronology extends Comparable<Chronology> {
* @throws DateTimeException if any of the values are out of range
* @since 9
*/
public default long epochSecond(int prolepticYear, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
public default long epochSecond(int prolepticYear, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
Objects.requireNonNull(zoneOffset, "zoneOffset");
HOUR_OF_DAY.checkValidValue(hour);
MINUTE_OF_HOUR.checkValidValue(minute);
@ -765,8 +765,8 @@ public interface Chronology extends Comparable<Chronology> {
* @throws DateTimeException if any of the values are out of range
* @since 9
*/
public default long epochSecond(Era era, int yearOfEra, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
public default long epochSecond(Era era, int yearOfEra, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
Objects.requireNonNull(era, "era");
return epochSecond(prolepticYear(era, yearOfEra), month, dayOfMonth, hour, minute, second, zoneOffset);
}

6
src/java.base/share/classes/java/time/chrono/IsoChronology.java
View File

@ -287,9 +287,9 @@ public final class IsoChronology extends AbstractChronology implements Serializa
* or if the day-of-month is invalid for the month-of-year
* @since 9
*/
@Override
public long epochSecond(int prolepticYear, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
@Override
public long epochSecond(int prolepticYear, int month, int dayOfMonth,
int hour, int minute, int second, ZoneOffset zoneOffset) {
YEAR.checkValidValue(prolepticYear);
MONTH_OF_YEAR.checkValidValue(month);
DAY_OF_MONTH.checkValidValue(dayOfMonth);

64
src/java.base/share/classes/java/time/chrono/JapaneseChronology.java
View File

@ -459,38 +459,38 @@ public final class JapaneseChronology extends AbstractChronology implements Seri
return era.getPrivateEra().getSinceDate().getYear() + yearOfEra - 1;
}
private ChronoLocalDate resolveYMD(JapaneseEra era, int yoe, Map<TemporalField,Long> fieldValues, ResolverStyle resolverStyle) {
fieldValues.remove(ERA);
fieldValues.remove(YEAR_OF_ERA);
if (resolverStyle == ResolverStyle.LENIENT) {
int y = prolepticYearLenient(era, yoe);
long months = Math.subtractExact(fieldValues.remove(MONTH_OF_YEAR), 1);
long days = Math.subtractExact(fieldValues.remove(DAY_OF_MONTH), 1);
return date(y, 1, 1).plus(months, MONTHS).plus(days, DAYS);
}
int moy = range(MONTH_OF_YEAR).checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR), MONTH_OF_YEAR);
int dom = range(DAY_OF_MONTH).checkValidIntValue(fieldValues.remove(DAY_OF_MONTH), DAY_OF_MONTH);
if (resolverStyle == ResolverStyle.SMART) { // previous valid
if (yoe < 1) {
throw new DateTimeException("Invalid YearOfEra: " + yoe);
}
int y = prolepticYearLenient(era, yoe);
JapaneseDate result;
try {
result = date(y, moy, dom);
} catch (DateTimeException ex) {
result = date(y, moy, 1).with(TemporalAdjusters.lastDayOfMonth());
}
// handle the era being changed
// only allow if the new date is in the same Jan-Dec as the era change
// determine by ensuring either original yoe or result yoe is 1
if (result.getEra() != era && result.get(YEAR_OF_ERA) > 1 && yoe > 1) {
throw new DateTimeException("Invalid YearOfEra for Era: " + era + " " + yoe);
}
return result;
}
return date(era, yoe, moy, dom);
}
private ChronoLocalDate resolveYMD(JapaneseEra era, int yoe, Map<TemporalField,Long> fieldValues, ResolverStyle resolverStyle) {
fieldValues.remove(ERA);
fieldValues.remove(YEAR_OF_ERA);
if (resolverStyle == ResolverStyle.LENIENT) {
int y = prolepticYearLenient(era, yoe);
long months = Math.subtractExact(fieldValues.remove(MONTH_OF_YEAR), 1);
long days = Math.subtractExact(fieldValues.remove(DAY_OF_MONTH), 1);
return date(y, 1, 1).plus(months, MONTHS).plus(days, DAYS);
}
int moy = range(MONTH_OF_YEAR).checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR), MONTH_OF_YEAR);
int dom = range(DAY_OF_MONTH).checkValidIntValue(fieldValues.remove(DAY_OF_MONTH), DAY_OF_MONTH);
if (resolverStyle == ResolverStyle.SMART) { // previous valid
if (yoe < 1) {
throw new DateTimeException("Invalid YearOfEra: " + yoe);
}
int y = prolepticYearLenient(era, yoe);
JapaneseDate result;
try {
result = date(y, moy, dom);
} catch (DateTimeException ex) {
result = date(y, moy, 1).with(TemporalAdjusters.lastDayOfMonth());
}
// handle the era being changed
// only allow if the new date is in the same Jan-Dec as the era change
// determine by ensuring either original yoe or result yoe is 1
if (result.getEra() != era && result.get(YEAR_OF_ERA) > 1 && yoe > 1) {
throw new DateTimeException("Invalid YearOfEra for Era: " + era + " " + yoe);
}
return result;
}
return date(era, yoe, moy, dom);
}
private ChronoLocalDate resolveYD(JapaneseEra era, int yoe, Map <TemporalField,Long> fieldValues, ResolverStyle resolverStyle) {
fieldValues.remove(ERA);

2
src/java.base/share/classes/java/time/format/DateTimeFormatterBuilder.java
View File

@ -3049,7 +3049,7 @@ public final class DateTimeFormatterBuilder {
* Prints and parses a numeric date-time field with optional padding.
*/
static final class FractionPrinterParser extends NumberPrinterParser {
private final boolean decimalPoint;
private final boolean decimalPoint;
/**
* Constructor.

1
src/java.base/share/classes/java/time/format/DecimalStyle.java
View File

@ -216,7 +216,6 @@ public final class DecimalStyle {
*
* @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) {

2
src/java.base/share/classes/java/time/zone/ZoneRulesProvider.java
View File

@ -119,7 +119,7 @@ import java.util.Collections;
* Providers must ensure that once a rule has been seen by the application, the
* rule must continue to be available.
* <p>
* Providers are encouraged to implement a meaningful {@code toString} method.
* Providers are encouraged to implement a meaningful {@code toString} method.
* <p>
* Many systems would like to update time-zone rules dynamically without stopping the JVM.
* When examined in detail, this is a complex problem.