Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/time/chrono/MinguoDate.java
/* * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ /* * Copyright (c) 2012, Stephen Colebourne & Michael Nascimento Santos * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * * Neither the name of JSR-310 nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * 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.InvalidObjectException; import java.io.ObjectInputStream; 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.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.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)}. * * <p> * This is a <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a> * class; use of identity-sensitive operations (including reference equality * ({@code ==}), identity hash code, or synchronization) on instances of * {@code MinguoDate} may have unpredictable results and should be avoided. * The {@code equals} method should be used for comparisons. * * @implSpec * This class is immutable and thread-safe. * * @since 1.8 */ public final class MinguoDate extends ChronoLocalDateImpl<MinguoDate> implements ChronoLocalDate, Serializable { /** * Serialization version. */ private static final long serialVersionUID = 1300372329181994526L; /** * The underlying date. */ private final transient 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 new MinguoDate(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 */ MinguoDate(LocalDate isoDate) { Objects.requireNonNull(isoDate, "isoDate"); this.isoDate = isoDate; } //----------------------------------------------------------------------- /** * Gets the chronology of this date, which is the Minguo 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 Minguo chronology, not null */ @Override public MinguoChronology getChronology() { return MinguoChronology.INSTANCE; } /** * Gets the era applicable at this date. * <p> * The Minguo calendar system has two eras, 'ROC' and 'BEFORE_ROC', * defined by {@link MinguoEra}. * * @return the era applicable at this date, not null */ @Override public MinguoEra getEra() { return (getProlepticYear() >= 1 ? MinguoEra.ROC : MinguoEra.BEFORE_ROC); } /** * 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 DAY_OF_YEAR: case ALIGNED_WEEK_OF_MONTH: return isoDate.range(field); case YEAR_OF_ERA: { 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 UnsupportedTemporalTypeException("Unsupported field: " + field); } return field.rangeRefinedBy(this); } @Override public long getLong(TemporalField field) { if (field instanceof ChronoField) { switch ((ChronoField) field) { case PROLEPTIC_MONTH: return getProlepticMonth(); case YEAR_OF_ERA: { int prolepticYear = getProlepticYear(); return (prolepticYear >= 1 ? prolepticYear : 1 - prolepticYear); } case YEAR: return getProlepticYear(); case ERA: return (getProlepticYear() >= 1 ? 1 : 0); } return isoDate.getLong(field); } return field.getFrom(this); } private long getProlepticMonth() { return getProlepticYear() * 12L + isoDate.getMonthValue() - 1; } private int getProlepticYear() { return isoDate.getYear() - YEARS_DIFFERENCE; } //----------------------------------------------------------------------- @Override public MinguoDate with(TemporalField field, long newValue) { if (field instanceof ChronoField) { ChronoField f = (ChronoField) field; if (getLong(f) == newValue) { return this; } switch (f) { case PROLEPTIC_MONTH: getChronology().range(f).checkValidValue(newValue, f); return plusMonths(newValue - getProlepticMonth()); case YEAR_OF_ERA: case YEAR: case ERA: { int nvalue = getChronology().range(f).checkValidIntValue(newValue, f); switch (f) { case YEAR_OF_ERA: return with(isoDate.withYear(getProlepticYear() >= 1 ? nvalue + YEARS_DIFFERENCE : (1 - nvalue) + YEARS_DIFFERENCE)); case YEAR: return with(isoDate.withYear(nvalue + YEARS_DIFFERENCE)); case ERA: return with(isoDate.withYear((1 - getProlepticYear()) + YEARS_DIFFERENCE)); } } } return with(isoDate.with(field, newValue)); } return super.with(field, newValue); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override public MinguoDate with(TemporalAdjuster adjuster) { return super.with(adjuster); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override public MinguoDate plus(TemporalAmount amount) { return super.plus(amount); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override public MinguoDate minus(TemporalAmount amount) { return super.minus(amount); } //----------------------------------------------------------------------- @Override MinguoDate plusYears(long years) { return with(isoDate.plusYears(years)); } @Override MinguoDate plusMonths(long months) { return with(isoDate.plusMonths(months)); } @Override MinguoDate plusWeeks(long weeksToAdd) { return super.plusWeeks(weeksToAdd); } @Override MinguoDate plusDays(long days) { return with(isoDate.plusDays(days)); } @Override public MinguoDate plus(long amountToAdd, TemporalUnit unit) { return super.plus(amountToAdd, unit); } @Override public MinguoDate minus(long amountToAdd, TemporalUnit unit) { return super.minus(amountToAdd, unit); } @Override MinguoDate minusYears(long yearsToSubtract) { return super.minusYears(yearsToSubtract); } @Override MinguoDate minusMonths(long monthsToSubtract) { return super.minusMonths(monthsToSubtract); } @Override MinguoDate minusWeeks(long weeksToSubtract) { return super.minusWeeks(weeksToSubtract); } @Override MinguoDate minusDays(long daysToSubtract) { return super.minusDays(daysToSubtract); } private MinguoDate with(LocalDate newDate) { return (newDate.equals(isoDate) ? this : new MinguoDate(newDate)); } @Override // for javadoc and covariant return type @SuppressWarnings("unchecked") public final ChronoLocalDateTime<MinguoDate> atTime(LocalTime localTime) { return (ChronoLocalDateTime<MinguoDate>)super.atTime(localTime); } @Override public ChronoPeriod until(ChronoLocalDate endDate) { Period period = isoDate.until(endDate); return getChronology().period(period.getYears(), period.getMonths(), period.getDays()); } @Override // override for performance public long toEpochDay() { return isoDate.toEpochDay(); } //------------------------------------------------------------------------- /** * Compares this date to another date, including the chronology. * <p> * Compares this {@code MinguoDate} with another ensuring that the date is the same. * <p> * Only objects of type {@code MinguoDate} are compared, other types return false. * To compare the dates of two {@code TemporalAccessor} instances, including dates * in two different chronologies, use {@link ChronoField#EPOCH_DAY} as a comparator. * * @param obj the object to check, null returns false * @return true if this is equal to the other date */ @Override // override for performance public boolean equals(Object obj) { if (this == obj) { return true; } if (obj instanceof MinguoDate) { MinguoDate otherDate = (MinguoDate) obj; return this.isoDate.equals(otherDate.isoDate); } return false; } /** * A hash code for this date. * * @return a suitable hash code based only on the Chronology and the date */ @Override // override for performance public int hashCode() { return getChronology().getId().hashCode() ^ isoDate.hashCode(); } //----------------------------------------------------------------------- /** * 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"); } /** * Writes the object using a * <a href="../../../serialized-form.html#java.time.chrono.Ser">dedicated serialized form</a>. * @serialData * <pre> * out.writeByte(8); // identifies a MinguoDate * out.writeInt(get(YEAR)); * out.writeByte(get(MONTH_OF_YEAR)); * out.writeByte(get(DAY_OF_MONTH)); * </pre> * * @return the instance of {@code Ser}, not null */ 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 MinguoDate readExternal(DataInput in) throws IOException { int year = in.readInt(); int month = in.readByte(); int dayOfMonth = in.readByte(); return MinguoChronology.INSTANCE.date(year, month, dayOfMonth); } }
⏎ java/time/chrono/MinguoDate.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 205216👍, 0💬
Popular Posts:
ANTLR is a powerful parser generator for multiple programming languages including Java. ANTLR contai...
What Is ojdbc7.jar for Oracle 12c R1? ojdbc7.jar for Oracle 12c R1 is the JAR files of ojdbc.jar, JD...
What Is HttpComponents httpclient-4.2.2.jar? HttpComponents httpclient-4.2.2.jar is the JAR file for...
MXP1 is a stable XmlPull parsing engine that is based on ideas from XPP and in particular XPP2 but c...
JDK 17 java.xml.jmod is the JMOD file for JDK 17 XML (eXtensible Markup Language) module. JDK 17 XML...