src/share/classes/java/time/chrono/JapaneseDate.java
Print this page
*** 52,99 ****
* 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.calendar;
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
- import java.io.ObjectInputStream;
import java.io.Serializable;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.temporal.ChronoField;
! import java.time.temporal.ChronoLocalDate;
import java.time.temporal.TemporalField;
import java.time.temporal.ValueRange;
import java.util.Calendar;
import java.util.Objects;
import sun.util.calendar.LocalGregorianCalendar;
/**
* A date in the Japanese Imperial calendar system.
* <p>
! * This implements {@code ChronoLocalDate} for the
! * {@linkplain JapaneseChrono Japanese Imperial calendar}.
*
* <h3>Specification for implementors</h3>
* This class is immutable and thread-safe.
*
* @since 1.8
*/
! final class JapaneseDate
! extends ChronoDateImpl<JapaneseChrono>
! implements ChronoLocalDate<JapaneseChrono>, Serializable {
! // this class is package-scoped so that future conversion to public
! // would not change serialization
/**
* Serialization version.
*/
private static final long serialVersionUID = -305327627230580483L;
--- 52,114 ----
* 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.chrono;
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.Serializable;
+ 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;
/**
* A date in the Japanese Imperial calendar system.
* <p>
! * This date operates using the {@linkplain JapaneseChronology Japanese Imperial calendar}.
! * This calendar system is primarily used in Japan.
! * <p>
! * The Japanese Imperial calendar system is the same as the ISO calendar system
! * apart from the era-based year numbering. The proleptic-year is defined to be
! * equal to the ISO proleptic-year.
! * <p>
! * For example, the Japanese year "Heisei 24" corresponds to ISO year "2012".<br>
! * Calling {@code japaneseDate.get(YEAR_OF_ERA)} will return 24.<br>
! * Calling {@code japaneseDate.get(YEAR)} will return 2012.<br>
! * Calling {@code japaneseDate.get(ERA)} will return 2, corresponding to
! * {@code JapaneseChronology.ERA_HEISEI}.<br>
*
* <h3>Specification for implementors</h3>
* This class is immutable and thread-safe.
*
* @since 1.8
*/
! public final class JapaneseDate
! extends ChronoDateImpl<JapaneseDate>
! implements ChronoLocalDate<JapaneseDate>, Serializable {
/**
* Serialization version.
*/
private static final long serialVersionUID = -305327627230580483L;
*** 109,141 ****
/**
* The Japanese imperial calendar year of this date.
*/
private transient int yearOfEra;
/**
! * Obtains an instance of {@code JapaneseDate} from the era, year-of-era,
! * month-of-year and day-of-month.
*
! * @param era the era to represent, not null
! * @param yearOfEra the year-of-era to represent
! * @param month the month-of-year to represent
! * @param dayOfMonth the day-of-month to represent, from 1 to 31
! * @return the Japanese date, never null
! * @throws DateTimeException if the value of any field is out of range, or
! * if the day-of-month is invalid for the month-year
*/
static JapaneseDate of(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
Objects.requireNonNull(era, "era");
! LocalGregorianCalendar.Date jdate = JapaneseChrono.JCAL.newCalendarDate(null);
jdate.setEra(era.getPrivateEra()).setDate(yearOfEra, month, dayOfMonth);
! if (!JapaneseChrono.JCAL.validate(jdate)) {
throw new IllegalArgumentException();
}
LocalDate date = LocalDate.of(jdate.getNormalizedYear(), month, dayOfMonth);
return new JapaneseDate(era, yearOfEra, date);
}
//-----------------------------------------------------------------------
/**
* Creates an instance from an ISO date.
*
* @param isoDate the standard local date, validated not null
--- 124,286 ----
/**
* The Japanese imperial calendar year of this date.
*/
private transient int yearOfEra;
+ //-----------------------------------------------------------------------
+ /**
+ * Obtains the current {@code JapaneseDate} from the system clock in the default time-zone.
+ * <p>
+ * This will query the {@link Clock#systemDefaultZone() system clock} in the default
+ * time-zone to obtain the current date.
+ * <p>
+ * Using this method will prevent the ability to use an alternate clock for testing
+ * because the clock is hard-coded.
+ *
+ * @return the current date using the system clock and default time-zone, not null
+ */
+ public static JapaneseDate now() {
+ return now(Clock.systemDefaultZone());
+ }
+
+ /**
+ * Obtains the current {@code JapaneseDate} from the system clock in the specified time-zone.
+ * <p>
+ * 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.
+ * <p>
+ * Using this method will prevent the ability to use an alternate clock for testing
+ * because the clock is hard-coded.
+ *
+ * @param zone the zone ID to use, not null
+ * @return the current date using the system clock, not null
+ */
+ public static JapaneseDate now(ZoneId zone) {
+ return now(Clock.system(zone));
+ }
+
/**
! * Obtains the current {@code JapaneseDate} from the specified clock.
! * <p>
! * 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 {@linkplain Clock dependency injection}.
*
! * @param clock the clock to use, not null
! * @return the current date, not null
! * @throws DateTimeException if the current date cannot be obtained
! */
! public static JapaneseDate now(Clock clock) {
! return JapaneseChronology.INSTANCE.date(LocalDate.now(clock));
! }
!
! /**
! * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
! * system from the era, year-of-era, month-of-year and day-of-month fields.
! * <p>
! * This returns a {@code JapaneseDate} with the specified fields.
! * The day must be valid for the year and month, otherwise an exception will be thrown.
! *
! * @param era the Japanese era, not null
! * @param yearOfEra the Japanese year-of-era
! * @param month the Japanese month-of-year, from 1 to 12
! * @param dayOfMonth the Japanese day-of-month, from 1 to 31
! * @return the date in Japanese calendar system, not null
! * @throws DateTimeException if the value of any field is out of range,
! * 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);
! }
!
! /**
! * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
! * system from the proleptic-year, month-of-year and day-of-month fields.
! * <p>
! * This returns a {@code JapaneseDate} with the specified fields.
! * The day must be valid for the year and month, otherwise an exception will be thrown.
! *
! * @param prolepticYear the Japanese proleptic-year
! * @param month the Japanese month-of-year, from 1 to 12
! * @param dayOfMonth the Japanese day-of-month, from 1 to 31
! * @return the date in Japanese calendar system, not null
! * @throws DateTimeException if the value of any field is out of range,
! * or if the day-of-month is invalid for the month-year
! */
! public static JapaneseDate of(int prolepticYear, int month, int dayOfMonth) {
! return new JapaneseDate(LocalDate.of(prolepticYear, month, dayOfMonth));
! }
!
! /**
! * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
! * system from the proleptic-year and day-of-year fields.
! * <p>
! * This returns a {@code JapaneseDate} with the specified fields.
! * The day must be valid for the year, otherwise an exception will be thrown.
! *
! * @param prolepticYear the chronology proleptic-year
! * @param dayOfYear the chronology day-of-year, from 1 to 366
! * @return the date in Japanese calendar system, not null
! * @throws DateTimeException if the value of any field is out of range,
! * or if the day-of-year is invalid for the year
! */
! public static JapaneseDate ofYearDay(int prolepticYear, int dayOfYear) {
! LocalDate date = LocalDate.ofYearDay(prolepticYear, dayOfYear);
! return of(prolepticYear, date.getMonthValue(), date.getDayOfMonth());
! }
!
! /**
! * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
! * system from the era, year-of-era, month-of-year and day-of-month fields.
! * <p>
! * This returns a {@code JapaneseDate} with the specified fields.
! * The day must be valid for the year and month, otherwise an exception will be thrown.
! *
! * @param era the Japanese era, not null
! * @param yearOfEra the Japanese year-of-era
! * @param month the Japanese month-of-year, from 1 to 12
! * @param dayOfMonth the Japanese day-of-month, from 1 to 31
! * @return the date in Japanese calendar system, not null
! * @throws DateTimeException if the value of any field is out of range,
! * or if the day-of-month is invalid for the month-year
*/
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);
}
+ /**
+ * Obtains a {@code JapaneseDate} from a temporal object.
+ * <p>
+ * This obtains a date in the Japanese calendar system based on the specified temporal.
+ * A {@code TemporalAccessor} represents an arbitrary set of date and time information,
+ * which this factory converts to an instance of {@code JapaneseDate}.
+ * <p>
+ * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY}
+ * field, which is standardized across calendar systems.
+ * <p>
+ * This method matches the signature of the functional interface {@link TemporalQuery}
+ * allowing it to be used as a query via method reference, {@code JapaneseDate::from}.
+ *
+ * @param temporal the temporal object to convert, not null
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if unable to convert to a {@code JapaneseDate}
+ */
+ public static JapaneseDate from(TemporalAccessor temporal) {
+ return JapaneseChronology.INSTANCE.date(temporal);
+ }
+
//-----------------------------------------------------------------------
/**
* Creates an instance from an ISO date.
*
* @param isoDate the standard local date, validated not null
*** 161,172 ****
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
! public JapaneseChrono getChrono() {
! return JapaneseChrono.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
--- 306,317 ----
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
! public JapaneseChronology getChronology() {
! return JapaneseChronology.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
*** 181,199 ****
case DAY_OF_YEAR:
return actualRange(Calendar.DAY_OF_YEAR);
case YEAR_OF_ERA:
return actualRange(Calendar.YEAR);
}
! return getChrono().range(f);
}
throw new DateTimeException("Unsupported field: " + field.getName());
}
! return field.doRange(this);
}
private ValueRange actualRange(int calendarField) {
! Calendar jcal = Calendar.getInstance(JapaneseChrono.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));
}
--- 326,344 ----
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));
}
*** 206,239 ****
return yearOfEra;
case ERA:
return era.getValue();
case DAY_OF_YEAR: {
LocalGregorianCalendar.Date jdate = toPrivateJapaneseDate(isoDate);
! return JapaneseChrono.JCAL.getDayOfYear(jdate);
}
}
// TODO: review other fields
return isoDate.getLong(field);
}
! return field.doGet(this);
}
/**
* Returns a {@code LocalGregorianCalendar.Date} converted from the given {@code isoDate}.
*
* @param isoDate the local date, not null
* @return a {@code LocalGregorianCalendar.Date}, not null
*/
private static LocalGregorianCalendar.Date toPrivateJapaneseDate(LocalDate isoDate) {
! LocalGregorianCalendar.Date jdate = JapaneseChrono.JCAL.newCalendarDate(null);
sun.util.calendar.Era sunEra = JapaneseEra.privateEraFrom(isoDate);
int year = isoDate.getYear();
if (sunEra != null) {
year -= sunEra.getSinceDate().getYear() - 1;
}
jdate.setEra(sunEra).setYear(year).setMonth(isoDate.getMonthValue()).setDayOfMonth(isoDate.getDayOfMonth());
! JapaneseChrono.JCAL.normalize(jdate);
return jdate;
}
//-----------------------------------------------------------------------
@Override
--- 351,384 ----
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);
}
/**
* Returns a {@code LocalGregorianCalendar.Date} converted from the given {@code isoDate}.
*
* @param isoDate the local date, not null
* @return a {@code LocalGregorianCalendar.Date}, not null
*/
private static LocalGregorianCalendar.Date toPrivateJapaneseDate(LocalDate isoDate) {
! LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
sun.util.calendar.Era sunEra = JapaneseEra.privateEraFrom(isoDate);
int year = isoDate.getYear();
if (sunEra != null) {
year -= sunEra.getSinceDate().getYear() - 1;
}
jdate.setEra(sunEra).setYear(year).setMonth(isoDate.getMonthValue()).setDayOfMonth(isoDate.getDayOfMonth());
! JapaneseChronology.JCAL.normalize(jdate);
return jdate;
}
//-----------------------------------------------------------------------
@Override
*** 264,273 ****
--- 409,452 ----
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>
* This method changes the year of the date.
*** 280,290 ****
* @param yearOfEra the year-of-era to set in the returned date
* @return a {@code JapaneseDate} based on this date with the requested year, never null
* @throws DateTimeException if {@code year} is invalid
*/
private JapaneseDate withYear(JapaneseEra era, int yearOfEra) {
! int year = JapaneseChrono.INSTANCE.prolepticYear(era, yearOfEra);
return with(isoDate.withYear(year));
}
/**
* Returns a copy of this date with the year-of-era altered.
--- 459,469 ----
* @param yearOfEra the year-of-era to set in the returned date
* @return a {@code JapaneseDate} based on this date with the requested year, never null
* @throws DateTimeException if {@code year} is invalid
*/
private JapaneseDate withYear(JapaneseEra era, int yearOfEra) {
! int year = JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra);
return with(isoDate.withYear(year));
}
/**
* Returns a copy of this date with the year-of-era altered.
*** 313,330 ****
--- 492,554 ----
JapaneseDate plusMonths(long months) {
return with(isoDate.plusMonths(months));
}
@Override
+ JapaneseDate plusWeeks(long weeksToAdd) {
+ return with(isoDate.plusWeeks(weeksToAdd));
+ }
+
+ @Override
JapaneseDate plusDays(long days) {
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);
+ }
+
@Override // override for performance
public long toEpochDay() {
return isoDate.toEpochDay();
}
*** 341,377 ****
return false;
}
@Override // override for performance
public int hashCode() {
! return getChrono().getId().hashCode() ^ isoDate.hashCode();
}
@Override
public String toString() {
if (era == JapaneseEra.SEIREKI) {
! return getChrono().getId() + " " + isoDate.toString();
}
return super.toString();
}
//-----------------------------------------------------------------------
private Object writeReplace() {
return new Ser(Ser.JAPANESE_DATE_TYPE, this);
}
void writeExternal(DataOutput out) throws IOException {
! // JapaneseChrono is implicit in the JAPANESE_DATE_TYPE
out.writeInt(get(YEAR));
out.writeByte(get(MONTH_OF_YEAR));
out.writeByte(get(DAY_OF_MONTH));
}
! static ChronoLocalDate<JapaneseChrono> readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
! return JapaneseChrono.INSTANCE.date(year, month, dayOfMonth);
}
-
}
--- 565,600 ----
return false;
}
@Override // override for performance
public int hashCode() {
! return getChronology().getId().hashCode() ^ isoDate.hashCode();
}
@Override
public String toString() {
if (era == JapaneseEra.SEIREKI) {
! return getChronology().getId() + " " + isoDate.toString();
}
return super.toString();
}
//-----------------------------------------------------------------------
private Object writeReplace() {
return new Ser(Ser.JAPANESE_DATE_TYPE, this);
}
void writeExternal(DataOutput out) throws IOException {
! // JapaneseChronology is implicit in the JAPANESE_DATE_TYPE
out.writeInt(get(YEAR));
out.writeByte(get(MONTH_OF_YEAR));
out.writeByte(get(DAY_OF_MONTH));
}
! static JapaneseDate readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
! return JapaneseChronology.INSTANCE.date(year, month, dayOfMonth);
}
}