@Override protected JapaneseEra eraOf(final String id) { return JapaneseEra.valueOf(id); }
switch (field) { case ERA: { JapaneseEra[] eras = JapaneseEra.values(); return ValueRange.of(eras[0].getValue(), eras[eras.length - 1].getValue()); JapaneseEra[] eras = JapaneseEra.values(); return ValueRange.of(JapaneseDate.MIN_DATE.getYear(), eras[eras.length - 1].endDate().getYear()); JapaneseEra[] eras = JapaneseEra.values(); int maxIso = eras[eras.length - 1].endDate().getYear(); int maxJapanese = maxIso - eras[eras.length - 1].startDate().getYear() + 1; int min = Integer.MAX_VALUE; for (int i = 0; i < eras.length; i++) { min = Math.min(min, eras[i].endDate().getYear() - eras[i].startDate().getYear() + 1); jcal.getLeastMaximum(Calendar.MONTH) + 1, jcal.getMaximum(Calendar.MONTH) + 1); case DAY_OF_YEAR: { JapaneseEra[] eras = JapaneseEra.values(); int min = 366; for (int i = 0; i < eras.length; i++) { min = Math.min(min, eras[i].startDate().lengthOfYear() - eras[i].startDate().getDayOfYear() + 1);
void writeExternal(DataOutput out) throws IOException { out.writeByte(this.getValue()); }
/** * Returns the calendar system era object from the given numeric value. * * See the description of each Era for the numeric values of: * {@link JapaneseEra#HEISEI}, {@link JapaneseEra#SHOWA},{@link JapaneseEra#TAISHO}, * {@link JapaneseEra#MEIJI}), only Meiji and later eras are supported. * * @param eraValue the era value * @return the Japanese {@code Era} for the given numeric era value * @throws DateTimeException if {@code eraValue} is invalid */ @Override public JapaneseEra eraOf(int eraValue) { return JapaneseEra.of(eraValue); }
@Override public int prolepticYear(Era era, int yearOfEra) { if (era instanceof JapaneseEra == false) { throw new ClassCastException("Era must be JapaneseEra"); } JapaneseEra jera = (JapaneseEra) era; int isoYear = jera.startDate().getYear() + yearOfEra - 1; ValueRange range = ValueRange.of(1, jera.endDate().getYear() - jera.startDate().getYear() + 1); range.checkValidValue(yearOfEra, YEAR_OF_ERA); return isoYear; }
private JapaneseDate resolveEYMD(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle, JapaneseEra era, int yoe) { if (resolverStyle == ResolverStyle.LENIENT) { int y = era.startDate().getYear() + yoe - 1; long months = Jdk8Methods.safeSubtract(fieldValues.remove(MONTH_OF_YEAR), 1); long days = Jdk8Methods.safeSubtract(fieldValues.remove(DAY_OF_MONTH), 1); throw new DateTimeException("Invalid YearOfEra: " + yoe); int y = era.startDate().getYear() + yoe - 1; if (dom > 28) { dom = Math.min(dom, date(y, moy, 1).lengthOfMonth()); if (jd.getEra() != era) { if (Math.abs(jd.getEra().getValue() - era.getValue()) > 1) { throw new DateTimeException("Invalid Era/YearOfEra: " + era + " " + yoe);
/** * Returns the Sun private Era instance corresponding to this {@code JapaneseEra}. * SEIREKI doesn't have its corresponding one. * * @return the Sun private Era instance for this {@code JapaneseEra}, * or null for SEIREKI. */ sun.util.calendar.Era getPrivateEra() { return ERA_CONFIG[ordinal(eraValue)]; }
/** * Reconstitutes this object from a stream. * * @param stream object input stream */ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); this.era = JapaneseEra.from(isoDate); int yearOffset = this.era.startDate().getYear() - 1; this.yearOfEra = isoDate.getYear() - yearOffset; }
@Override public String toString() { return getName(); }
private static Object readInternal(byte type, ObjectInput in) throws IOException, ClassNotFoundException { switch (type) { case JAPANESE_DATE_TYPE: return JapaneseDate.readExternal(in); case JAPANESE_ERA_TYPE: return JapaneseEra.readExternal(in); case HIJRAH_DATE_TYPE: return HijrahDate.readExternal(in); case HIJRAH_ERA_TYPE: return HijrahEra.readExternal(in); case MINGUO_DATE_TYPE: return MinguoDate.readExternal(in); case MINGUO_ERA_TYPE: return MinguoEra.readExternal(in); case THAIBUDDHIST_DATE_TYPE: return ThaiBuddhistDate.readExternal(in); case THAIBUDDHIST_ERA_TYPE: return ThaiBuddhistEra.readExternal(in); case CHRONO_TYPE: return Chronology.readExternal(in); case CHRONO_LOCALDATETIME_TYPE: return ChronoLocalDateTimeImpl.readExternal(in); case CHRONO_ZONEDDATETIME_TYPE: return ChronoZonedDateTimeImpl.readExternal(in); default: throw new StreamCorruptedException("Unknown serialized type"); } }
private long getDayOfYear() { if (yearOfEra == 1) { return isoDate.getDayOfYear() - era.startDate().getDayOfYear() + 1; } return isoDate.getDayOfYear(); }
@Override public int lengthOfYear() { Calendar jcal = Calendar.getInstance(JapaneseChronology.LOCALE); jcal.set(Calendar.ERA, era.getValue() + JapaneseEra.ERA_OFFSET); jcal.set(yearOfEra, isoDate.getMonthValue() - 1, isoDate.getDayOfMonth()); return jcal.getActualMaximum(Calendar.DAY_OF_YEAR); }
static JapaneseEra readExternal(DataInput in) throws IOException { byte eraValue = in.readByte(); return JapaneseEra.of(eraValue); }
/** * Obtains an instance of {@code JapaneseEra} from an {@code int} value. * <p> * The {@link #SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1 * Later era is numbered 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}), * -1 ({@link #MEIJI}), only Meiji and later eras are supported. * * @param japaneseEra the era to represent * @return the {@code JapaneseEra} singleton, not null * @throws DateTimeException if the value is invalid */ public static JapaneseEra of(int japaneseEra) { if (japaneseEra < MEIJI.eraValue || japaneseEra + ERA_OFFSET - 1 >= KNOWN_ERAS.length) { throw new DateTimeException("japaneseEra is invalid"); } return KNOWN_ERAS[ordinal(japaneseEra)]; }
/** * Creates an instance from an ISO date. * * @param isoDate the standard local date, validated not null */ JapaneseDate(LocalDate isoDate) { if (isoDate.isBefore(MIN_DATE)) { throw new DateTimeException("Minimum supported date is January 1st Meiji 6"); } this.era = JapaneseEra.from(isoDate); int yearOffset = this.era.startDate().getYear() - 1; this.yearOfEra = isoDate.getYear() - yearOffset; this.isoDate = isoDate; }
/** * Returns the {@code JapaneseEra} with the name. * <p> * The string must match exactly the name of the era. * (Extraneous whitespace characters are not permitted.) * * @param japaneseEra the japaneseEra name; non-null * @return the {@code JapaneseEra} singleton, never null * @throws IllegalArgumentException if there is not JapaneseEra with the specified name */ public static JapaneseEra valueOf(String japaneseEra) { Jdk8Methods.requireNonNull(japaneseEra, "japaneseEra"); for (JapaneseEra era : KNOWN_ERAS) { if (japaneseEra.equals(era.getName())) { return era; } } throw new IllegalArgumentException("Era not found: " + japaneseEra); }