src/share/classes/java/time/chrono/JapaneseDate.java
Print this page
*** 67,84 ****
import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.temporal.ChronoField;
- import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalUnit;
import java.time.temporal.ValueRange;
import java.util.Calendar;
import java.util.Objects;
import sun.util.calendar.LocalGregorianCalendar;
--- 67,86 ----
import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
+ import java.time.Year;
import java.time.ZoneId;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
+ import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalUnit;
+ import java.time.temporal.UnsupportedTemporalTypeException;
import java.time.temporal.ValueRange;
import java.util.Calendar;
import java.util.Objects;
import sun.util.calendar.LocalGregorianCalendar;
*** 189,199 ****
* or if the day-of-month is invalid for the month-year,
* or if the date is not a Japanese era
*/
public static JapaneseDate of(Era era, int yearOfEra, int month, int dayOfMonth) {
if (era instanceof JapaneseEra == false) {
! throw new DateTimeException("Era must be JapaneseEra");
}
return JapaneseDate.of((JapaneseEra) era, yearOfEra, month, dayOfMonth);
}
/**
--- 191,201 ----
* or if the day-of-month is invalid for the month-year,
* or if the date is not a Japanese era
*/
public static JapaneseDate of(Era era, int yearOfEra, int month, int dayOfMonth) {
if (era instanceof JapaneseEra == false) {
! throw new ClassCastException("Era must be JapaneseEra");
}
return JapaneseDate.of((JapaneseEra) era, yearOfEra, month, dayOfMonth);
}
/**
*** 250,260 ****
static JapaneseDate of(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
Objects.requireNonNull(era, "era");
LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
jdate.setEra(era.getPrivateEra()).setDate(yearOfEra, month, dayOfMonth);
if (!JapaneseChronology.JCAL.validate(jdate)) {
! throw new IllegalArgumentException();
}
LocalDate date = LocalDate.of(jdate.getNormalizedYear(), month, dayOfMonth);
return new JapaneseDate(era, yearOfEra, date);
}
--- 252,262 ----
static JapaneseDate of(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
Objects.requireNonNull(era, "era");
LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
jdate.setEra(era.getPrivateEra()).setDate(yearOfEra, month, dayOfMonth);
if (!JapaneseChronology.JCAL.validate(jdate)) {
! throw new DateTimeException("year, month, and day not valid for Era");
}
LocalDate date = LocalDate.of(jdate.getNormalizedYear(), month, dayOfMonth);
return new JapaneseDate(era, yearOfEra, date);
}
*** 305,364 ****
this.yearOfEra = year;
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
public JapaneseChronology getChronology() {
return JapaneseChronology.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
}
@Override
public ValueRange range(TemporalField field) {
if (field instanceof ChronoField) {
if (isSupported(field)) {
ChronoField f = (ChronoField) field;
switch (f) {
case DAY_OF_YEAR:
return actualRange(Calendar.DAY_OF_YEAR);
case YEAR_OF_ERA:
return actualRange(Calendar.YEAR);
}
return getChronology().range(f);
}
! throw new DateTimeException("Unsupported field: " + field.getName());
}
return field.rangeRefinedBy(this);
}
private ValueRange actualRange(int calendarField) {
Calendar jcal = Calendar.getInstance(JapaneseChronology.LOCALE);
! jcal.set(Calendar.ERA, era.getValue() + JapaneseEra.ERA_OFFSET);
jcal.set(yearOfEra, isoDate.getMonthValue() - 1, isoDate.getDayOfMonth());
return ValueRange.of(jcal.getActualMinimum(calendarField),
jcal.getActualMaximum(calendarField));
}
@Override
public long getLong(TemporalField field) {
if (field instanceof ChronoField) {
switch ((ChronoField) field) {
case YEAR_OF_ERA:
return yearOfEra;
case ERA:
return era.getValue();
case DAY_OF_YEAR: {
LocalGregorianCalendar.Date jdate = toPrivateJapaneseDate(isoDate);
return JapaneseChronology.JCAL.getDayOfYear(jdate);
}
}
- // TODO: review other fields
return isoDate.getLong(field);
}
return field.getFrom(this);
}
--- 307,404 ----
this.yearOfEra = year;
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
+ /**
+ * Gets the chronology of this date, which is the Japanese calendar system.
+ * <p>
+ * The {@code Chronology} represents the calendar system in use.
+ * The era and other fields in {@link ChronoField} are defined by the chronology.
+ *
+ * @return the Japanese chronology, not null
+ */
@Override
public JapaneseChronology getChronology() {
return JapaneseChronology.INSTANCE;
}
+ /**
+ * Gets the era applicable at this date.
+ * <p>
+ * The Japanese calendar system has multiple eras defined by {@link JapaneseEra}.
+ *
+ * @return the era applicable at this date, not null
+ */
+ @Override
+ public JapaneseEra getEra() {
+ return era;
+ }
+
+ /**
+ * Returns the length of the month represented by this date.
+ * <p>
+ * This returns the length of the month in days.
+ * Month lengths match those of the ISO calendar system.
+ *
+ * @return the length of the month in days
+ */
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
}
+ //-----------------------------------------------------------------------
@Override
public ValueRange range(TemporalField field) {
if (field instanceof ChronoField) {
if (isSupported(field)) {
ChronoField f = (ChronoField) field;
switch (f) {
+ case DAY_OF_MONTH:
+ case ALIGNED_WEEK_OF_MONTH:
+ return isoDate.range(field);
case DAY_OF_YEAR:
return actualRange(Calendar.DAY_OF_YEAR);
case YEAR_OF_ERA:
return actualRange(Calendar.YEAR);
}
return getChronology().range(f);
}
! throw new UnsupportedTemporalTypeException("Unsupported field: " + field.getName());
}
return field.rangeRefinedBy(this);
}
private ValueRange actualRange(int calendarField) {
Calendar jcal = Calendar.getInstance(JapaneseChronology.LOCALE);
! jcal.set(Calendar.ERA, era.getValue() + JapaneseEra.ERA_OFFSET); // TODO: cannot calculate this way for SEIREKI
jcal.set(yearOfEra, isoDate.getMonthValue() - 1, isoDate.getDayOfMonth());
return ValueRange.of(jcal.getActualMinimum(calendarField),
jcal.getActualMaximum(calendarField));
}
@Override
public long getLong(TemporalField field) {
if (field instanceof ChronoField) {
+ // same as ISO:
+ // DAY_OF_WEEK, ALIGNED_DAY_OF_WEEK_IN_MONTH, DAY_OF_MONTH, EPOCH_DAY,
+ // ALIGNED_WEEK_OF_MONTH, MONTH_OF_YEAR, PROLEPTIC_MONTH, YEAR
+ //
+ // calendar specific fields
+ // ALIGNED_DAY_OF_WEEK_IN_YEAR, DAY_OF_YEAR, ALIGNED_WEEK_OF_YEAR, YEAR_OF_ERA, ERA
switch ((ChronoField) field) {
case YEAR_OF_ERA:
return yearOfEra;
case ERA:
return era.getValue();
case DAY_OF_YEAR: {
LocalGregorianCalendar.Date jdate = toPrivateJapaneseDate(isoDate);
return JapaneseChronology.JCAL.getDayOfYear(jdate);
}
+ // TODO: ALIGNED_DAY_OF_WEEK_IN_YEAR and ALIGNED_WEEK_OF_YEAR ???
}
return isoDate.getLong(field);
}
return field.getFrom(this);
}
*** 390,401 ****
}
switch (f) {
case YEAR_OF_ERA:
case YEAR:
case ERA: {
! f.checkValidValue(newValue);
! int nvalue = (int) newValue;
switch (f) {
case YEAR_OF_ERA:
return this.withYear(nvalue);
case YEAR:
return with(isoDate.withYear(nvalue));
--- 430,440 ----
}
switch (f) {
case YEAR_OF_ERA:
case YEAR:
case ERA: {
! int nvalue = getChronology().range(f).checkValidIntValue(newValue, f);
switch (f) {
case YEAR_OF_ERA:
return this.withYear(nvalue);
case YEAR:
return with(isoDate.withYear(nvalue));
*** 403,451 ****
return this.withYear(JapaneseEra.of(nvalue), yearOfEra);
}
}
}
}
// TODO: review other fields, such as WEEK_OF_YEAR
return with(isoDate.with(field, newValue));
}
! return (JapaneseDate) ChronoLocalDate.super.with(field, newValue);
! }
!
! @Override
! public Era getEra() {
! return era;
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate with(TemporalAdjuster adjuster) {
! return (JapaneseDate)super.with(adjuster);
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate plus(TemporalAmount amount) {
! return (JapaneseDate)super.plus(amount);
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate minus(TemporalAmount amount) {
! return (JapaneseDate)super.minus(amount);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this date with the year altered.
* <p>
--- 442,486 ----
return this.withYear(JapaneseEra.of(nvalue), yearOfEra);
}
}
}
}
+ // YEAR, PROLEPTIC_MONTH and others are same as ISO
// TODO: review other fields, such as WEEK_OF_YEAR
return with(isoDate.with(field, newValue));
}
! return ChronoLocalDate.super.with(field, newValue);
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate with(TemporalAdjuster adjuster) {
! return super.with(adjuster);
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate plus(TemporalAmount amount) {
! return super.plus(amount);
}
/**
* {@inheritDoc}
* @throws DateTimeException {@inheritDoc}
* @throws ArithmeticException {@inheritDoc}
*/
@Override
public JapaneseDate minus(TemporalAmount amount) {
! return super.minus(amount);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this date with the year altered.
* <p>
*** 477,487 ****
* @param year the year to set in the returned date
* @return a {@code JapaneseDate} based on this date with the requested year-of-era, never null
* @throws DateTimeException if {@code year} is invalid
*/
private JapaneseDate withYear(int year) {
! return withYear((JapaneseEra) getEra(), year);
}
//-----------------------------------------------------------------------
@Override
JapaneseDate plusYears(long years) {
--- 512,522 ----
* @param year the year to set in the returned date
* @return a {@code JapaneseDate} based on this date with the requested year-of-era, never null
* @throws DateTimeException if {@code year} is invalid
*/
private JapaneseDate withYear(int year) {
! return withYear(getEra(), year);
}
//-----------------------------------------------------------------------
@Override
JapaneseDate plusYears(long years) {
*** 503,547 ****
return with(isoDate.plusDays(days));
}
@Override
public JapaneseDate plus(long amountToAdd, TemporalUnit unit) {
! return (JapaneseDate)super.plus(amountToAdd, unit);
}
@Override
public JapaneseDate minus(long amountToAdd, TemporalUnit unit) {
! return (JapaneseDate)super.minus(amountToAdd, unit);
}
@Override
JapaneseDate minusYears(long yearsToSubtract) {
! return (JapaneseDate)super.minusYears(yearsToSubtract);
}
@Override
JapaneseDate minusMonths(long monthsToSubtract) {
! return (JapaneseDate)super.minusMonths(monthsToSubtract);
}
@Override
JapaneseDate minusWeeks(long weeksToSubtract) {
! return (JapaneseDate)super.minusWeeks(weeksToSubtract);
}
@Override
JapaneseDate minusDays(long daysToSubtract) {
! return (JapaneseDate)super.minusDays(daysToSubtract);
}
private JapaneseDate with(LocalDate newDate) {
return (newDate.equals(isoDate) ? this : new JapaneseDate(newDate));
}
@Override // for javadoc and covariant return type
public final ChronoLocalDateTime<JapaneseDate> atTime(LocalTime localTime) {
! return (ChronoLocalDateTime<JapaneseDate>)super.atTime(localTime);
}
@Override
public Period periodUntil(ChronoLocalDate<?> endDate) {
return isoDate.periodUntil(endDate);
--- 538,582 ----
return with(isoDate.plusDays(days));
}
@Override
public JapaneseDate plus(long amountToAdd, TemporalUnit unit) {
! return super.plus(amountToAdd, unit);
}
@Override
public JapaneseDate minus(long amountToAdd, TemporalUnit unit) {
! return super.minus(amountToAdd, unit);
}
@Override
JapaneseDate minusYears(long yearsToSubtract) {
! return super.minusYears(yearsToSubtract);
}
@Override
JapaneseDate minusMonths(long monthsToSubtract) {
! return super.minusMonths(monthsToSubtract);
}
@Override
JapaneseDate minusWeeks(long weeksToSubtract) {
! return super.minusWeeks(weeksToSubtract);
}
@Override
JapaneseDate minusDays(long daysToSubtract) {
! return super.minusDays(daysToSubtract);
}
private JapaneseDate with(LocalDate newDate) {
return (newDate.equals(isoDate) ? this : new JapaneseDate(newDate));
}
@Override // for javadoc and covariant return type
public final ChronoLocalDateTime<JapaneseDate> atTime(LocalTime localTime) {
! return super.atTime(localTime);
}
@Override
public Period periodUntil(ChronoLocalDate<?> endDate) {
return isoDate.periodUntil(endDate);