src/share/classes/java/time/chrono/MinguoDate.java
Print this page
*** 52,95 ****
* 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.calendar.MinguoChrono.YEARS_DIFFERENCE;
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.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.Objects;
/**
* A date in the Minguo calendar system.
* <p>
! * This implements {@code ChronoLocalDate} for the {@link MinguoChrono Minguo calendar}.
*
* <h3>Specification for implementors</h3>
* This class is immutable and thread-safe.
*
* @since 1.8
*/
! final class MinguoDate
! extends ChronoDateImpl<MinguoChrono>
! implements ChronoLocalDate<MinguoChrono>, Serializable {
! // this class is package-scoped so that future conversion to public
! // would not change serialization
/**
* Serialization version.
*/
private static final long serialVersionUID = 1300372329181994526L;
--- 52,103 ----
* 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.chrono.MinguoChronology.YEARS_DIFFERENCE;
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.Objects;
/**
* A date in the Minguo calendar system.
* <p>
! * This date operates using the {@linkplain MinguoChronology Minguo calendar}.
! * This calendar system is primarily used in the Republic of China, often known as Taiwan.
! * Dates are aligned such that {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
*
* <h3>Specification for implementors</h3>
* This class is immutable and thread-safe.
*
* @since 1.8
*/
! public final class MinguoDate
! extends ChronoDateImpl<MinguoDate>
! implements ChronoLocalDate<MinguoDate>, Serializable {
/**
* Serialization version.
*/
private static final long serialVersionUID = 1300372329181994526L;
*** 97,106 ****
--- 105,201 ----
/**
* The underlying date.
*/
private final LocalDate isoDate;
+ //-----------------------------------------------------------------------
+ /**
+ * Obtains the current {@code MinguoDate} 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 MinguoDate now() {
+ return now(Clock.systemDefaultZone());
+ }
+
+ /**
+ * Obtains the current {@code MinguoDate} 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 MinguoDate now(ZoneId zone) {
+ return now(Clock.system(zone));
+ }
+
+ /**
+ * Obtains the current {@code MinguoDate} 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 MinguoDate now(Clock clock) {
+ return MinguoChronology.INSTANCE.date(LocalDate.now(clock));
+ }
+
+ /**
+ * Obtains a {@code MinguoDate} representing a date in the Minguo calendar
+ * system from the proleptic-year, month-of-year and day-of-month fields.
+ * <p>
+ * This returns a {@code MinguoDate} with the specified fields.
+ * The day must be valid for the year and month, otherwise an exception will be thrown.
+ *
+ * @param prolepticYear the Minguo proleptic-year
+ * @param month the Minguo month-of-year, from 1 to 12
+ * @param dayOfMonth the Minguo day-of-month, from 1 to 31
+ * @return the date in Minguo 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 MinguoDate of(int prolepticYear, int month, int dayOfMonth) {
+ return new MinguoDate(LocalDate.of(prolepticYear + YEARS_DIFFERENCE, month, dayOfMonth));
+ }
+
+ /**
+ * Obtains a {@code MinguoDate} from a temporal object.
+ * <p>
+ * This obtains a date in the Minguo 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 MinguoDate}.
+ * <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 MinguoDate::from}.
+ *
+ * @param temporal the temporal object to convert, not null
+ * @return the date in Minguo calendar system, not null
+ * @throws DateTimeException if unable to convert to a {@code MinguoDate}
+ */
+ public static MinguoDate from(TemporalAccessor temporal) {
+ return MinguoChronology.INSTANCE.date(temporal);
+ }
+
+ //-----------------------------------------------------------------------
/**
* Creates an instance from an ISO date.
*
* @param isoDate the standard local date, validated not null
*/
*** 109,120 ****
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
! public MinguoChrono getChrono() {
! return MinguoChrono.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
--- 204,215 ----
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
! public MinguoChronology getChronology() {
! return MinguoChronology.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
*** 134,148 ****
ValueRange range = YEAR.range();
long max = (getProlepticYear() <= 0 ? -range.getMinimum() + 1 + YEARS_DIFFERENCE : range.getMaximum() - YEARS_DIFFERENCE);
return ValueRange.of(1, max);
}
}
! return getChrono().range(f);
}
throw new DateTimeException("Unsupported field: " + field.getName());
}
! return field.doRange(this);
}
@Override
public long getLong(TemporalField field) {
if (field instanceof ChronoField) {
--- 229,243 ----
ValueRange range = YEAR.range();
long max = (getProlepticYear() <= 0 ? -range.getMinimum() + 1 + YEARS_DIFFERENCE : range.getMaximum() - YEARS_DIFFERENCE);
return ValueRange.of(1, max);
}
}
! return getChronology().range(f);
}
throw new DateTimeException("Unsupported field: " + field.getName());
}
! return field.rangeRefinedBy(this);
}
@Override
public long getLong(TemporalField field) {
if (field instanceof ChronoField) {
*** 156,166 ****
case ERA:
return (getProlepticYear() >= 1 ? 1 : 0);
}
return isoDate.getLong(field);
}
! return field.doGet(this);
}
private int getProlepticYear() {
return isoDate.getYear() - YEARS_DIFFERENCE;
}
--- 251,261 ----
case ERA:
return (getProlepticYear() >= 1 ? 1 : 0);
}
return isoDate.getLong(field);
}
! return field.getFrom(this);
}
private int getProlepticYear() {
return isoDate.getYear() - YEARS_DIFFERENCE;
}
*** 192,201 ****
--- 287,326 ----
return with(isoDate.with(field, newValue));
}
return (MinguoDate) ChronoLocalDate.super.with(field, newValue);
}
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public MinguoDate with(TemporalAdjuster adjuster) {
+ return (MinguoDate)super.with(adjuster);
+ }
+
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public MinguoDate plus(TemporalAmount amount) {
+ return (MinguoDate)super.plus(amount);
+ }
+
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public MinguoDate minus(TemporalAmount amount) {
+ return (MinguoDate)super.minus(amount);
+ }
+
//-----------------------------------------------------------------------
@Override
MinguoDate plusYears(long years) {
return with(isoDate.plusYears(years));
}
*** 208,221 ****
--- 333,391 ----
@Override
MinguoDate plusDays(long days) {
return with(isoDate.plusDays(days));
}
+ @Override
+ public MinguoDate plus(long amountToAdd, TemporalUnit unit) {
+ return (MinguoDate)super.plus(amountToAdd, unit);
+ }
+
+ @Override
+ public MinguoDate minus(long amountToAdd, TemporalUnit unit) {
+ return (MinguoDate)super.minus(amountToAdd, unit);
+ }
+
+ @Override
+ MinguoDate plusWeeks(long weeksToAdd) {
+ return (MinguoDate)super.plusWeeks(weeksToAdd);
+ }
+
+ @Override
+ MinguoDate minusYears(long yearsToSubtract) {
+ return (MinguoDate)super.minusYears(yearsToSubtract);
+ }
+
+ @Override
+ MinguoDate minusMonths(long monthsToSubtract) {
+ return (MinguoDate)super.minusMonths(monthsToSubtract);
+ }
+
+ @Override
+ MinguoDate minusWeeks(long weeksToSubtract) {
+ return (MinguoDate)super.minusWeeks(weeksToSubtract);
+ }
+
+ @Override
+ MinguoDate minusDays(long daysToSubtract) {
+ return (MinguoDate)super.minusDays(daysToSubtract);
+ }
+
private MinguoDate with(LocalDate newDate) {
return (newDate.equals(isoDate) ? this : new MinguoDate(newDate));
}
+ @Override // for javadoc and covariant return type
+ public final ChronoLocalDateTime<MinguoDate> atTime(LocalTime localTime) {
+ return (ChronoLocalDateTime<MinguoDate>)super.atTime(localTime);
+ }
+
+ @Override
+ public Period periodUntil(ChronoLocalDate<?> endDate) {
+ return isoDate.periodUntil(endDate);
+ }
+
@Override // override for performance
public long toEpochDay() {
return isoDate.toEpochDay();
}
*** 232,261 ****
return false;
}
@Override // override for performance
public int hashCode() {
! return getChrono().getId().hashCode() ^ isoDate.hashCode();
}
//-----------------------------------------------------------------------
private Object writeReplace() {
return new Ser(Ser.MINGUO_DATE_TYPE, this);
}
void writeExternal(DataOutput out) throws IOException {
! // MinguoChrono is implicit in the MINGUO_DATE_TYPE
out.writeInt(get(YEAR));
out.writeByte(get(MONTH_OF_YEAR));
out.writeByte(get(DAY_OF_MONTH));
-
}
! static ChronoLocalDate<MinguoChrono> readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
! return MinguoChrono.INSTANCE.date(year, month, dayOfMonth);
}
-
}
--- 402,429 ----
return false;
}
@Override // override for performance
public int hashCode() {
! return getChronology().getId().hashCode() ^ isoDate.hashCode();
}
//-----------------------------------------------------------------------
private Object writeReplace() {
return new Ser(Ser.MINGUO_DATE_TYPE, this);
}
void writeExternal(DataOutput out) throws IOException {
! // MinguoChronology is implicit in the MINGUO_DATE_TYPE
out.writeInt(get(YEAR));
out.writeByte(get(MONTH_OF_YEAR));
out.writeByte(get(DAY_OF_MONTH));
}
! static ChronoLocalDate readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
! return MinguoChronology.INSTANCE.date(year, month, dayOfMonth);
}
}