485 lines
18 KiB
Java
485 lines
18 KiB
Java
/* GENERATED SOURCE. DO NOT MODIFY. */
|
|
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 1996-2014, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
*******************************************************************************
|
|
*/
|
|
package android.icu.util;
|
|
import java.util.Date;
|
|
import java.util.Locale;
|
|
|
|
import android.icu.impl.CalType;
|
|
import android.icu.impl.EraRules;
|
|
|
|
/**
|
|
* <code>JapaneseCalendar</code> is a subclass of <code>GregorianCalendar</code>
|
|
* that numbers years and eras based on the reigns of the Japanese emperors.
|
|
* The Japanese calendar is identical to the Gregorian calendar in all respects
|
|
* except for the year and era. The ascension of each emperor to the throne
|
|
* begins a new era, and the years of that era are numbered starting with the
|
|
* year of ascension as year 1.
|
|
* <p>
|
|
* Note that in the year of an imperial ascension, there are two possible sets
|
|
* of year and era values: that for the old era and for the new. For example, a
|
|
* new era began on January 7, 1989 AD. Strictly speaking, the first six days
|
|
* of that year were in the Showa era, e.g. "January 6, 64 Showa", while the rest
|
|
* of the year was in the Heisei era, e.g. "January 7, 1 Heisei". This class
|
|
* handles this distinction correctly when computing dates. However, in lenient
|
|
* mode either form of date is acceptable as input.
|
|
* <p>
|
|
* In modern times, eras have started on January 8, 1868 AD, Gregorian (Meiji),
|
|
* July 30, 1912 (Taisho), December 25, 1926 (Showa), and January 7, 1989 (Heisei). Constants
|
|
* for these eras, suitable for use in the <code>ERA</code> field, are provided
|
|
* in this class. Note that the <em>number</em> used for each era is more or
|
|
* less arbitrary. Currently, the era starting in 645 AD is era #0; however this
|
|
* may change in the future. Use the predefined constants rather than using actual,
|
|
* absolute numbers.
|
|
* <p>
|
|
* Since ICU4J 63, start date of each era is imported from CLDR. CLDR era data
|
|
* may contain tentative era in near future with placeholder names. By default,
|
|
* such era data is not enabled. ICU4J users who want to test the behavior of
|
|
* the future era can enable this by one of following settings (in the priority
|
|
* order):
|
|
* <ol>
|
|
* <li>Java system property <code>ICU_ENABLE_TENTATIVE_ERA=true</code>.</li>
|
|
* <li>Environment variable <code>ICU_ENABLE_TENTATIVE_ERA=true</code>.</li>
|
|
* <li>Java system property <code>jdk.calendar.japanese.supplemental.era=xxx</code>.
|
|
* (Note: This configuration is used for specifying a new era's start date and
|
|
* names in OpenJDK. ICU4J implementation enables the CLDR tentative era when
|
|
* this property is defined, but it does not use the start date and names specified
|
|
* by the property value.)</li>
|
|
* </ol>
|
|
* <p>
|
|
* This class should not be subclassed.</p>
|
|
* <p>
|
|
* JapaneseCalendar usually should be instantiated using
|
|
* {@link android.icu.util.Calendar#getInstance(ULocale)} passing in a <code>ULocale</code>
|
|
* with the tag <code>"@calendar=japanese"</code>.</p>
|
|
*
|
|
* @see android.icu.util.GregorianCalendar
|
|
* @see android.icu.util.Calendar
|
|
*
|
|
* @author Laura Werner
|
|
* @author Alan Liu
|
|
*/
|
|
public class JapaneseCalendar extends GregorianCalendar {
|
|
// jdk1.4.2 serialver
|
|
private static final long serialVersionUID = -2977189902603704691L;
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Constructors...
|
|
//-------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Constructs a default <code>JapaneseCalendar</code> using the current time
|
|
* in the default time zone with the default locale.
|
|
*/
|
|
public JapaneseCalendar() {
|
|
super();
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> based on the current time
|
|
* in the given time zone with the default locale.
|
|
* @param zone the given time zone.
|
|
*/
|
|
public JapaneseCalendar(TimeZone zone) {
|
|
super(zone);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> based on the current time
|
|
* in the default time zone with the given locale.
|
|
* @param aLocale the given locale.
|
|
*/
|
|
public JapaneseCalendar(Locale aLocale) {
|
|
super(aLocale);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> based on the current time
|
|
* in the default time zone with the given locale.
|
|
* @param locale the given ulocale.
|
|
*/
|
|
public JapaneseCalendar(ULocale locale) {
|
|
super(locale);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> based on the current time
|
|
* in the given time zone with the given locale.
|
|
*
|
|
* @param zone the given time zone.
|
|
*
|
|
* @param aLocale the given locale.
|
|
*/
|
|
public JapaneseCalendar(TimeZone zone, Locale aLocale) {
|
|
super(zone, aLocale);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> based on the current time
|
|
* in the given time zone with the given locale.
|
|
*
|
|
* @param zone the given time zone.
|
|
*
|
|
* @param locale the given ulocale.
|
|
*/
|
|
public JapaneseCalendar(TimeZone zone, ULocale locale) {
|
|
super(zone, locale);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> with the given date set
|
|
* in the default time zone with the default locale.
|
|
*
|
|
* @param date The date to which the new calendar is set.
|
|
*/
|
|
public JapaneseCalendar(Date date) {
|
|
this();
|
|
setTime(date);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> with the given date set
|
|
* in the default time zone with the default locale.
|
|
*
|
|
* @param era The imperial era used to set the calendar's {@link #ERA ERA} field.
|
|
* Eras are numbered starting with the Tenki era, which
|
|
* began in 1053 AD Gregorian, as era zero. Recent
|
|
* eras can be specified using the constants
|
|
* {@link #MEIJI} (which started in 1868 AD),
|
|
* {@link #TAISHO} (1912 AD),
|
|
* {@link #SHOWA} (1926 AD), and
|
|
* {@link #HEISEI} (1989 AD).
|
|
*
|
|
* @param year The value used to set the calendar's {@link #YEAR YEAR} field,
|
|
* in terms of the era.
|
|
*
|
|
* @param month The value used to set the calendar's {@link #MONTH MONTH} field.
|
|
* The value is 0-based. e.g., 0 for January.
|
|
*
|
|
* @param date The value used to set the calendar's DATE field.
|
|
*/
|
|
public JapaneseCalendar(int era, int year, int month, int date) {
|
|
super(year, month, date);
|
|
set(ERA, era);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> with the given date set
|
|
* in the default time zone with the default locale.
|
|
*
|
|
* @param year The value used to set the calendar's {@link #YEAR YEAR} field,
|
|
* in the era Heisei, the most current at the time this
|
|
* class was last updated.
|
|
*
|
|
* @param month The value used to set the calendar's {@link #MONTH MONTH} field.
|
|
* The value is 0-based. e.g., 0 for January.
|
|
*
|
|
* @param date The value used to set the calendar's {@link #DATE DATE} field.
|
|
*/
|
|
public JapaneseCalendar(int year, int month, int date) {
|
|
super(year, month, date);
|
|
set(ERA, CURRENT_ERA);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>JapaneseCalendar</code> with the given date
|
|
* and time set for the default time zone with the default locale.
|
|
*
|
|
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field,
|
|
* in the era Heisei, the most current at the time of this
|
|
* writing.
|
|
*
|
|
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
|
|
* The value is 0-based. e.g., 0 for January.
|
|
*
|
|
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
|
|
*
|
|
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
|
|
*
|
|
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
|
|
*
|
|
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
|
|
*/
|
|
public JapaneseCalendar(int year, int month, int date, int hour,
|
|
int minute, int second)
|
|
{
|
|
super(year, month, date, hour, minute, second);
|
|
set(ERA, CURRENT_ERA);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
// Use 1970 as the default value of EXTENDED_YEAR
|
|
private static final int GREGORIAN_EPOCH = 1970;
|
|
|
|
private static final EraRules ERA_RULES;
|
|
|
|
static {
|
|
ERA_RULES = EraRules.getInstance(CalType.JAPANESE, enableTentativeEra());
|
|
}
|
|
|
|
/**
|
|
* Check environment variable that enables use of future eras.
|
|
* @deprecated This API is ICU internal only.
|
|
* @hide draft / provisional / internal are hidden on Android
|
|
*/
|
|
@Deprecated
|
|
public static boolean enableTentativeEra() {
|
|
// Although start date of next Japanese era is planned ahead, a name of
|
|
// new era might not be available. This implementation allows tester to
|
|
// check a new era without era names by settings below (in priority order).
|
|
// By default, such tentative era is disabled.
|
|
//
|
|
// 1. System property ICU_ENABLE_TENTATIVE_ERA=true or false
|
|
// 2. Environment variable ICU_ENABLE_TENTATIVE_ERA=true or false
|
|
// 3. Java system property - jdk.calendar.japanese.supplemental.era for Japanese
|
|
//
|
|
// Note: Java system property specifies the start date of new Japanese era,
|
|
// but this implementation always uses the date read from ICU data.
|
|
|
|
boolean includeTentativeEra = false;
|
|
|
|
final String VAR_NAME = "ICU_ENABLE_TENTATIVE_ERA";
|
|
|
|
String eraConf = System.getProperty(VAR_NAME);
|
|
if (eraConf == null) {
|
|
eraConf = System.getenv(VAR_NAME);
|
|
}
|
|
|
|
if (eraConf != null) {
|
|
includeTentativeEra = eraConf.equalsIgnoreCase("true");
|
|
} else {
|
|
String jdkEraConf = System.getProperty("jdk.calendar.japanese.supplemental.era");
|
|
includeTentativeEra = jdkEraConf != null;
|
|
}
|
|
return includeTentativeEra;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
@Override
|
|
protected int handleGetExtendedYear() {
|
|
// EXTENDED_YEAR in JapaneseCalendar is a Gregorian year
|
|
// The default value of EXTENDED_YEAR is 1970 (Showa 45)
|
|
int year;
|
|
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR &&
|
|
newerField(EXTENDED_YEAR, ERA) == EXTENDED_YEAR) {
|
|
year = internalGet(EXTENDED_YEAR, GREGORIAN_EPOCH);
|
|
} else {
|
|
// extended year is a gregorian year, where 1 = 1AD, 0 = 1BC, -1 = 2BC, etc
|
|
year = internalGet(YEAR, 1) // pin to minimum of year 1 (first year)
|
|
+ ERA_RULES.getStartYear(internalGet(ERA, CURRENT_ERA)) // add gregorian starting year
|
|
- 1; // Subtract one because year starts at 1
|
|
}
|
|
return year;
|
|
}
|
|
|
|
/**
|
|
* Called by handleComputeJulianDay. Returns the default month (0-based) for the year,
|
|
* taking year and era into account. Defaults to 0 (JANUARY) for Gregorian.
|
|
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
|
|
* @return the default month
|
|
* @see #MONTH
|
|
* @hide draft / provisional / internal are hidden on Android
|
|
*/
|
|
@Override
|
|
protected int getDefaultMonthInYear(int extendedYear) {
|
|
int era = internalGet(ERA, CURRENT_ERA);
|
|
// computeFields(status); // No need to compute fields here - expect the caller already did so.
|
|
|
|
// Find out if we are at the edge of an era
|
|
int[] eraStart = ERA_RULES.getStartDate(era, null);
|
|
if (extendedYear == eraStart[0]) {
|
|
return eraStart[1] // month..
|
|
- 1; // return 0-based month
|
|
} else {
|
|
return super.getDefaultMonthInYear(extendedYear);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called by handleComputeJulianDay. Returns the default day (1-based) for the month,
|
|
* taking currently-set year and era into account. Defaults to 1 for Gregorian.
|
|
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
|
|
* @param month the month, as returned by getDefaultMonthInYear
|
|
* @return the default day of the month
|
|
* @see #DAY_OF_MONTH
|
|
* @hide draft / provisional / internal are hidden on Android
|
|
*/
|
|
@Override
|
|
protected int getDefaultDayInMonth(int extendedYear, int month) {
|
|
int era = internalGet(ERA, CURRENT_ERA);
|
|
int[] eraStart = ERA_RULES.getStartDate(era, null);
|
|
|
|
if (extendedYear == eraStart[0]) { // if it is year 1..
|
|
if (month == (eraStart[1] - 1)) { // if it is the emperor's first month..
|
|
return eraStart[2]; // return the D_O_M of accession
|
|
}
|
|
}
|
|
|
|
return super.getDefaultDayInMonth(extendedYear, month);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
@Override
|
|
protected void handleComputeFields(int julianDay) {
|
|
super.handleComputeFields(julianDay);
|
|
int year = internalGet(EXTENDED_YEAR);
|
|
int eraIdx = ERA_RULES.getEraIndex(year, internalGet(MONTH) + 1 /* 1-base */, internalGet(DAY_OF_MONTH));
|
|
|
|
internalSet(ERA, eraIdx);
|
|
internalSet(YEAR, year - ERA_RULES.getStartYear(eraIdx) + 1);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Public constants for some of the recent eras that folks might use...
|
|
//-------------------------------------------------------------------------
|
|
|
|
// Constant for the current era. This must be regularly updated.
|
|
/**
|
|
* @deprecated Use era constants, e.g. {@link #REIWA}, instead.
|
|
* @removed on Android but @stable in ICU
|
|
*/
|
|
@Deprecated
|
|
static public final int CURRENT_ERA;
|
|
|
|
/**
|
|
* Constant for the era starting on Sept. 8, 1868 AD.
|
|
*/
|
|
static public final int MEIJI;
|
|
|
|
/**
|
|
* Constant for the era starting on July 30, 1912 AD.
|
|
*/
|
|
static public final int TAISHO;
|
|
|
|
/**
|
|
* Constant for the era starting on Dec. 25, 1926 AD.
|
|
*/
|
|
static public final int SHOWA;
|
|
|
|
/**
|
|
* Constant for the era starting on Jan. 7, 1989 AD.
|
|
*/
|
|
static public final int HEISEI;
|
|
|
|
/**
|
|
* Constant for the era starting on May 1, 2019 AD.
|
|
*/
|
|
static public final int REIWA;
|
|
|
|
// We want to make these era constants initialized in a static initializer
|
|
// block to prevent javac to inline these values in a consumer code.
|
|
// By doing so, we can keep better binary compatibility across versions even
|
|
// these values are changed.
|
|
static {
|
|
MEIJI = 232;
|
|
TAISHO = 233;
|
|
SHOWA = 234;
|
|
HEISEI = 235;
|
|
// Android-changed: Android doesn't use system time to initialize CURRENT_ERA.
|
|
// Android could initialize this class during device boot with incorrect time, and
|
|
// all forked process, e.g. app processes, may have incorrect current era.
|
|
// CURRENT_ERA = ERA_RULES.getCurrentEraIndex();
|
|
REIWA = 236;
|
|
CURRENT_ERA = REIWA;
|
|
}
|
|
|
|
/**
|
|
* Override GregorianCalendar. We should really handle YEAR_WOY and
|
|
* EXTENDED_YEAR here too to implement the 1..5000000 range, but it's
|
|
* not critical.
|
|
*/
|
|
@Override
|
|
@SuppressWarnings("fallthrough")
|
|
protected int handleGetLimit(int field, int limitType) {
|
|
switch (field) {
|
|
case ERA:
|
|
if (limitType == MINIMUM || limitType == GREATEST_MINIMUM) {
|
|
return 0;
|
|
}
|
|
return ERA_RULES.getNumberOfEras() - 1; // max known era, not always CURRENT_ERA
|
|
case YEAR:
|
|
{
|
|
switch (limitType) {
|
|
case MINIMUM:
|
|
case GREATEST_MINIMUM:
|
|
return 1;
|
|
case LEAST_MAXIMUM:
|
|
return 1;
|
|
case MAXIMUM:
|
|
return super.handleGetLimit(field, MAXIMUM) - ERA_RULES.getStartYear(CURRENT_ERA);
|
|
}
|
|
//Fall through to the default if not handled above
|
|
}
|
|
default:
|
|
return super.handleGetLimit(field, limitType);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
public String getType() {
|
|
return "japanese";
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @deprecated This API is ICU internal only.
|
|
* @hide original deprecated declaration
|
|
* @hide draft / provisional / internal are hidden on Android
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public boolean haveDefaultCentury() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
public int getActualMaximum(int field) {
|
|
if (field == YEAR) {
|
|
int era = get(Calendar.ERA);
|
|
if (era == ERA_RULES.getNumberOfEras() - 1) {
|
|
// TODO: Investigate what value should be used here - revisit after 4.0.
|
|
return handleGetLimit(YEAR, MAXIMUM);
|
|
} else {
|
|
int[] nextEraStart = ERA_RULES.getStartDate(era + 1, null);
|
|
int nextEraYear = nextEraStart[0];
|
|
int nextEraMonth = nextEraStart[1]; // 1-base
|
|
int nextEraDate = nextEraStart[2];
|
|
|
|
int maxYear = nextEraYear - ERA_RULES.getStartYear(era) + 1; // 1-base
|
|
if (nextEraMonth == 1 && nextEraDate == 1) {
|
|
// Substract 1, because the next era starts at Jan 1
|
|
maxYear--;
|
|
}
|
|
return maxYear;
|
|
}
|
|
}
|
|
return super.getActualMaximum(field);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* @deprecated This API is ICU internal only.
|
|
* @hide draft / provisional / internal are hidden on Android
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
protected boolean isEra0CountingBackward() {
|
|
return false;
|
|
}
|
|
}
|