* This chronology defines the rules of the ISO calendar system. * This calendar system is based on the ISO-8601 standard, which is the * de facto world calendar. *
* The fields are defined as follows: *
* The ID uniquely identifies the {@code Chronology}. * It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}. * * @return the chronology ID - 'ISO' * @see #getCalendarType() */ @Override public String getId() { return "ISO"; } /** * Gets the calendar type of the underlying calendar system - 'iso8601'. *
* The calendar type is an identifier defined by the * Unicode Locale Data Markup Language (LDML) specification. * It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}. * It can also be used as part of a locale, accessible via * {@link Locale#getUnicodeLocaleType(String)} with the key 'ca'. * * @return the calendar system type - 'iso8601' * @see #getId() */ @Override public String getCalendarType() { return "iso8601"; } //----------------------------------------------------------------------- /** * Obtains an ISO local date from the era, year-of-era, month-of-year * and day-of-month fields. * * @param era the ISO era, not null * @param yearOfEra the ISO year-of-era * @param month the ISO month-of-year * @param dayOfMonth the ISO day-of-month * @return the ISO local date, not null * @throws DateTimeException if unable to create the date * @throws ClassCastException if the type of {@code era} is not {@code IsoEra} */ @Override // override with covariant return type public LocalDate date(Era era, int yearOfEra, int month, int dayOfMonth) { return date(prolepticYear(era, yearOfEra), month, dayOfMonth); } /** * Obtains an ISO local date from the proleptic-year, month-of-year * and day-of-month fields. *
* This is equivalent to {@link LocalDate#of(int, int, int)}. * * @param prolepticYear the ISO proleptic-year * @param month the ISO month-of-year * @param dayOfMonth the ISO day-of-month * @return the ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate date(int prolepticYear, int month, int dayOfMonth) { return LocalDate.of(prolepticYear, month, dayOfMonth); } /** * Obtains an ISO local date from the era, year-of-era and day-of-year fields. * * @param era the ISO era, not null * @param yearOfEra the ISO year-of-era * @param dayOfYear the ISO day-of-year * @return the ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateYearDay(Era era, int yearOfEra, int dayOfYear) { return dateYearDay(prolepticYear(era, yearOfEra), dayOfYear); } /** * Obtains an ISO local date from the proleptic-year and day-of-year fields. *
* This is equivalent to {@link LocalDate#ofYearDay(int, int)}. * * @param prolepticYear the ISO proleptic-year * @param dayOfYear the ISO day-of-year * @return the ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateYearDay(int prolepticYear, int dayOfYear) { return LocalDate.ofYearDay(prolepticYear, dayOfYear); } /** * Obtains an ISO local date from the epoch-day. *
* This is equivalent to {@link LocalDate#ofEpochDay(long)}. * * @param epochDay the epoch day * @return the ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateEpochDay(long epochDay) { return LocalDate.ofEpochDay(epochDay); } //----------------------------------------------------------------------- /** * Obtains an ISO local date from another date-time object. *
* This is equivalent to {@link LocalDate#from(TemporalAccessor)}. * * @param temporal the date-time object to convert, not null * @return the ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate date(TemporalAccessor temporal) { return LocalDate.from(temporal); } //----------------------------------------------------------------------- /** * Gets the number of seconds from the epoch of 1970-01-01T00:00:00Z * formed using the specified year, month, day, hour, minute, second and zoneOffset. * * @param prolepticYear the year to represent, from MIN_YEAR to MAX_YEAR * @param month the month-of-year to represent, from 1 to 12 * @param dayOfMonth the day-of-month to represent, from 1 to 31 * @param hour the hour-of-day to represent, from 0 to 23 * @param minute the minute-of-hour to represent, from 0 to 59 * @param second the second-of-minute to represent, from 0 to 59 * @param zoneOffset the zone offset, not null * @return the number of seconds relative to 1970-01-01T00:00:00Z, may be negative * @throws DateTimeException if the value of any field is out of range, * or if the day-of-month is invalid for the month-year */ @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); HOUR_OF_DAY.checkValidValue(hour); MINUTE_OF_HOUR.checkValidValue(minute); SECOND_OF_MINUTE.checkValidValue(second); Objects.requireNonNull(zoneOffset, "zoneOffset"); if (dayOfMonth > 28) { int dom = numberOfDaysOfMonth(prolepticYear, month); if (dayOfMonth > dom) { if (dayOfMonth == 29) { throw new DateTimeException("Invalid date 'February 29' as '" + prolepticYear + "' is not a leap year"); } else { throw new DateTimeException("Invalid date '" + Month.of(month).name() + " " + dayOfMonth + "'"); } } } long totalDays = 0; int timeinSec = 0; totalDays += 365L * prolepticYear; long DAYS_0000_TO_1970 = (146097 * 5L) - (30L * 365L + 7L); // taken from LocalDate if (prolepticYear >= 0) { totalDays += (prolepticYear + 3L) / 4 - (prolepticYear + 99L) / 100 + (prolepticYear + 399L) / 400; } else { totalDays -= prolepticYear / -4 - prolepticYear / -100 + prolepticYear / -400; } totalDays += (367 * month - 362) / 12; totalDays += dayOfMonth - 1; if (month > 2) { totalDays--; if (IsoChronology.INSTANCE.isLeapYear(prolepticYear) == false) { totalDays--; } } totalDays -= DAYS_0000_TO_1970; timeinSec = (hour * 60 + minute ) * 60 + second; return Math.addExact(Math.multiplyExact(totalDays, 86400L), timeinSec - zoneOffset.getTotalSeconds()); } /** * Gets the number of days for the given month in the given year. * * @param year the year to represent, from MIN_YEAR to MAX_YEAR * @param month the month-of-year to represent, from 1 to 12 * @return the number of days for the given month in the given year */ private int numberOfDaysOfMonth(int year, int month) { int dom; switch (month) { case 2: dom = (IsoChronology.INSTANCE.isLeapYear(year) ? 29 : 28); break; case 4: case 6: case 9: case 11: dom = 30; break; default: dom = 31; break; } return dom; } /** * Obtains an ISO local date-time from another date-time object. *
* This is equivalent to {@link LocalDateTime#from(TemporalAccessor)}. * * @param temporal the date-time object to convert, not null * @return the ISO local date-time, not null * @throws DateTimeException if unable to create the date-time */ @Override // override with covariant return type public LocalDateTime localDateTime(TemporalAccessor temporal) { return LocalDateTime.from(temporal); } /** * Obtains an ISO zoned date-time from another date-time object. *
* This is equivalent to {@link ZonedDateTime#from(TemporalAccessor)}. * * @param temporal the date-time object to convert, not null * @return the ISO zoned date-time, not null * @throws DateTimeException if unable to create the date-time */ @Override // override with covariant return type public ZonedDateTime zonedDateTime(TemporalAccessor temporal) { return ZonedDateTime.from(temporal); } /** * Obtains an ISO zoned date-time in this chronology from an {@code Instant}. *
* This is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)}. * * @param instant the instant to create the date-time from, not null * @param zone the time-zone, not null * @return the zoned date-time, not null * @throws DateTimeException if the result exceeds the supported range */ @Override public ZonedDateTime zonedDateTime(Instant instant, ZoneId zone) { return ZonedDateTime.ofInstant(instant, zone); } //----------------------------------------------------------------------- /** * Obtains the current ISO local date from the system clock in the default time-zone. *
* This will query the {@link Clock#systemDefaultZone() system clock} in the default * time-zone to obtain the current date. *
* Using this method will prevent the ability to use an alternate clock for testing * because the clock is hard-coded. * * @return the current ISO local date using the system clock and default time-zone, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateNow() { return dateNow(Clock.systemDefaultZone()); } /** * Obtains the current ISO local date from the system clock in the specified time-zone. *
* This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date. * Specifying the time-zone avoids dependence on the default time-zone. *
* Using this method will prevent the ability to use an alternate clock for testing * because the clock is hard-coded. * * @return the current ISO local date using the system clock, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateNow(ZoneId zone) { return dateNow(Clock.system(zone)); } /** * Obtains the current ISO local date from the specified clock. *
* This will query the specified clock to obtain the current date - today. * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current ISO local date, not null * @throws DateTimeException if unable to create the date */ @Override // override with covariant return type public LocalDate dateNow(Clock clock) { Objects.requireNonNull(clock, "clock"); return date(LocalDate.now(clock)); } //----------------------------------------------------------------------- /** * Checks if the year is a leap year, according to the ISO proleptic * calendar system rules. *
* This method applies the current rules for leap years across the whole time-line. * In general, a year is a leap year if it is divisible by four without * remainder. However, years divisible by 100, are not leap years, with * the exception of years divisible by 400 which are. *
* For example, 1904 is a leap year it is divisible by 4. * 1900 was not a leap year as it is divisible by 100, however 2000 was a * leap year as it is divisible by 400. *
* The calculation is proleptic - applying the same rules into the far future and far past.
* This is historically inaccurate, but is correct for the ISO-8601 standard.
*
* @param prolepticYear the ISO proleptic year to check
* @return true if the year is leap, false otherwise
*/
@Override
public boolean isLeapYear(long prolepticYear) {
return ((prolepticYear & 3) == 0) && ((prolepticYear % 100) != 0 || (prolepticYear % 400) == 0);
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof IsoEra == false) {
throw new ClassCastException("Era must be IsoEra");
}
return (era == IsoEra.CE ? yearOfEra : 1 - yearOfEra);
}
@Override
public IsoEra eraOf(int eraValue) {
return IsoEra.of(eraValue);
}
@Override
public List
* Most {@code TemporalField} implementations are resolved using the
* resolve method on the field. By contrast, the {@code ChronoField} class
* defines fields that only have meaning relative to the chronology.
* As such, {@code ChronoField} date fields are resolved here in the
* context of a specific chronology.
*
* {@code ChronoField} instances on the ISO calendar system are resolved
* as follows.
*
* This returns a period tied to the ISO chronology using the specified
* years, months and days. See {@link Period} for further details.
*
* @param years the number of years, may be negative
* @param months the number of years, may be negative
* @param days the number of years, may be negative
* @return the period in terms of this chronology, not null
* @return the ISO period, not null
*/
@Override // override with covariant return type
public Period period(int years, int months, int days) {
return Period.of(years, months, days);
}
//-----------------------------------------------------------------------
/**
* Writes the Chronology using a
* dedicated serialized form.
* @serialData
*
*
*
* @param fieldValues the map of fields to values, which can be updated, not null
* @param resolverStyle the requested type of resolve, not null
* @return the resolved date, null if insufficient information to create a date
* @throws DateTimeException if the date cannot be resolved, typically
* because of a conflict in the input data
*/
@Override // override for performance
public LocalDate resolveDate(Map
* out.writeByte(1); // identifies a Chronology
* out.writeUTF(getId());
*
*
* @return the instance of {@code Ser}, not null
*/
@Override
Object writeReplace() {
return super.writeReplace();
}
/**
* Defend against malicious streams.
*
* @param s the stream to read
* @throws InvalidObjectException always
*/
private void readObject(ObjectInputStream s) throws InvalidObjectException {
throw new InvalidObjectException("Deserialization via serialization delegate");
}
}