758 lines
35 KiB
Java
758 lines
35 KiB
Java
/*
|
|
* Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* This file is available under and governed by the GNU General Public
|
|
* License version 2 only, as published by the Free Software Foundation.
|
|
* However, the following notice accompanied the original version of this
|
|
* file:
|
|
*
|
|
* 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.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH;
|
|
import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR;
|
|
import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_MONTH;
|
|
import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_YEAR;
|
|
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
|
|
import static java.time.temporal.ChronoField.DAY_OF_WEEK;
|
|
import static java.time.temporal.ChronoField.DAY_OF_YEAR;
|
|
import static java.time.temporal.ChronoField.EPOCH_DAY;
|
|
import static java.time.temporal.ChronoField.ERA;
|
|
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
|
|
import static java.time.temporal.ChronoField.PROLEPTIC_MONTH;
|
|
import static java.time.temporal.ChronoField.YEAR;
|
|
import static java.time.temporal.ChronoField.YEAR_OF_ERA;
|
|
import static java.time.temporal.ChronoUnit.DAYS;
|
|
import static java.time.temporal.ChronoUnit.MONTHS;
|
|
import static java.time.temporal.ChronoUnit.WEEKS;
|
|
import static java.time.temporal.TemporalAdjusters.nextOrSame;
|
|
|
|
import java.io.DataInput;
|
|
import java.io.DataOutput;
|
|
import java.io.IOException;
|
|
import java.io.InvalidObjectException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectStreamException;
|
|
import java.io.Serializable;
|
|
import java.time.DateTimeException;
|
|
import java.time.DayOfWeek;
|
|
import java.time.format.ResolverStyle;
|
|
import java.time.temporal.ChronoField;
|
|
import java.time.temporal.TemporalAdjusters;
|
|
import java.time.temporal.TemporalField;
|
|
import java.time.temporal.ValueRange;
|
|
import java.util.Comparator;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.ServiceLoader;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
import sun.util.logging.PlatformLogger;
|
|
|
|
/**
|
|
* An abstract implementation of a calendar system, used to organize and identify dates.
|
|
* <p>
|
|
* The main date and time API is built on the ISO calendar system.
|
|
* The chronology operates behind the scenes to represent the general concept of a calendar system.
|
|
* <p>
|
|
* See {@link Chronology} for more details.
|
|
*
|
|
* @implSpec
|
|
* This class is separated from the {@code Chronology} interface so that the static methods
|
|
* are not inherited. While {@code Chronology} can be implemented directly, it is strongly
|
|
* recommended to extend this abstract class instead.
|
|
* <p>
|
|
* This class must be implemented with care to ensure other classes operate correctly.
|
|
* All implementations that can be instantiated must be final, immutable and thread-safe.
|
|
* Subclasses should be Serializable wherever possible.
|
|
*
|
|
* @since 1.8
|
|
*/
|
|
public abstract class AbstractChronology implements Chronology {
|
|
|
|
/**
|
|
* Map of available calendars by ID.
|
|
*/
|
|
private static final ConcurrentHashMap<String, Chronology> CHRONOS_BY_ID = new ConcurrentHashMap<>();
|
|
/**
|
|
* Map of available calendars by calendar type.
|
|
*/
|
|
private static final ConcurrentHashMap<String, Chronology> CHRONOS_BY_TYPE = new ConcurrentHashMap<>();
|
|
|
|
/**
|
|
* Register a Chronology by its ID and type for lookup by {@link #of(String)}.
|
|
* Chronologies must not be registered until they are completely constructed.
|
|
* Specifically, not in the constructor of Chronology.
|
|
*
|
|
* @param chrono the chronology to register; not null
|
|
* @return the already registered Chronology if any, may be null
|
|
*/
|
|
static Chronology registerChrono(Chronology chrono) {
|
|
return registerChrono(chrono, chrono.getId());
|
|
}
|
|
|
|
/**
|
|
* Register a Chronology by ID and type for lookup by {@link #of(String)}.
|
|
* Chronos must not be registered until they are completely constructed.
|
|
* Specifically, not in the constructor of Chronology.
|
|
*
|
|
* @param chrono the chronology to register; not null
|
|
* @param id the ID to register the chronology; not null
|
|
* @return the already registered Chronology if any, may be null
|
|
*/
|
|
static Chronology registerChrono(Chronology chrono, String id) {
|
|
Chronology prev = CHRONOS_BY_ID.putIfAbsent(id, chrono);
|
|
if (prev == null) {
|
|
String type = chrono.getCalendarType();
|
|
if (type != null) {
|
|
CHRONOS_BY_TYPE.putIfAbsent(type, chrono);
|
|
}
|
|
}
|
|
return prev;
|
|
}
|
|
|
|
/**
|
|
* Initialization of the maps from id and type to Chronology.
|
|
* The ServiceLoader is used to find and register any implementations
|
|
* of {@link java.time.chrono.AbstractChronology} found in the bootclass loader.
|
|
* The built-in chronologies are registered explicitly.
|
|
* Calendars configured via the Thread's context classloader are local
|
|
* to that thread and are ignored.
|
|
* <p>
|
|
* The initialization is done only once using the registration
|
|
* of the IsoChronology as the test and the final step.
|
|
* Multiple threads may perform the initialization concurrently.
|
|
* Only the first registration of each Chronology is retained by the
|
|
* ConcurrentHashMap.
|
|
* @return true if the cache was initialized
|
|
*/
|
|
private static boolean initCache() {
|
|
if (CHRONOS_BY_ID.get("ISO") == null) {
|
|
// Initialization is incomplete
|
|
|
|
// Register built-in Chronologies
|
|
registerChrono(HijrahChronology.INSTANCE);
|
|
registerChrono(JapaneseChronology.INSTANCE);
|
|
registerChrono(MinguoChronology.INSTANCE);
|
|
registerChrono(ThaiBuddhistChronology.INSTANCE);
|
|
|
|
// Register Chronologies from the ServiceLoader
|
|
@SuppressWarnings("rawtypes")
|
|
ServiceLoader<AbstractChronology> loader = ServiceLoader.load(AbstractChronology.class, null);
|
|
for (AbstractChronology chrono : loader) {
|
|
String id = chrono.getId();
|
|
if (id.equals("ISO") || registerChrono(chrono) != null) {
|
|
// Log the attempt to replace an existing Chronology
|
|
PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
|
|
logger.warning("Ignoring duplicate Chronology, from ServiceLoader configuration " + id);
|
|
}
|
|
}
|
|
|
|
// finally, register IsoChronology to mark initialization is complete
|
|
registerChrono(IsoChronology.INSTANCE);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Obtains an instance of {@code Chronology} from a locale.
|
|
* <p>
|
|
* See {@link Chronology#ofLocale(Locale)}.
|
|
*
|
|
* @param locale the locale to use to obtain the calendar system, not null
|
|
* @return the calendar system associated with the locale, not null
|
|
* @throws java.time.DateTimeException if the locale-specified calendar cannot be found
|
|
*/
|
|
static Chronology ofLocale(Locale locale) {
|
|
Objects.requireNonNull(locale, "locale");
|
|
String type = locale.getUnicodeLocaleType("ca");
|
|
if (type == null || "iso".equals(type) || "iso8601".equals(type)) {
|
|
return IsoChronology.INSTANCE;
|
|
}
|
|
// Not pre-defined; lookup by the type
|
|
do {
|
|
Chronology chrono = CHRONOS_BY_TYPE.get(type);
|
|
if (chrono != null) {
|
|
return chrono;
|
|
}
|
|
// If not found, do the initialization (once) and repeat the lookup
|
|
} while (initCache());
|
|
|
|
// Look for a Chronology using ServiceLoader of the Thread's ContextClassLoader
|
|
// Application provided Chronologies must not be cached
|
|
@SuppressWarnings("rawtypes")
|
|
ServiceLoader<Chronology> loader = ServiceLoader.load(Chronology.class);
|
|
for (Chronology chrono : loader) {
|
|
if (type.equals(chrono.getCalendarType())) {
|
|
return chrono;
|
|
}
|
|
}
|
|
throw new DateTimeException("Unknown calendar system: " + type);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Obtains an instance of {@code Chronology} from a chronology ID or
|
|
* calendar system type.
|
|
* <p>
|
|
* See {@link Chronology#of(String)}.
|
|
*
|
|
* @param id the chronology ID or calendar system type, not null
|
|
* @return the chronology with the identifier requested, not null
|
|
* @throws java.time.DateTimeException if the chronology cannot be found
|
|
*/
|
|
static Chronology of(String id) {
|
|
Objects.requireNonNull(id, "id");
|
|
do {
|
|
Chronology chrono = of0(id);
|
|
if (chrono != null) {
|
|
return chrono;
|
|
}
|
|
// If not found, do the initialization (once) and repeat the lookup
|
|
} while (initCache());
|
|
|
|
// Look for a Chronology using ServiceLoader of the Thread's ContextClassLoader
|
|
// Application provided Chronologies must not be cached
|
|
@SuppressWarnings("rawtypes")
|
|
ServiceLoader<Chronology> loader = ServiceLoader.load(Chronology.class);
|
|
for (Chronology chrono : loader) {
|
|
if (id.equals(chrono.getId()) || id.equals(chrono.getCalendarType())) {
|
|
return chrono;
|
|
}
|
|
}
|
|
throw new DateTimeException("Unknown chronology: " + id);
|
|
}
|
|
|
|
/**
|
|
* Obtains an instance of {@code Chronology} from a chronology ID or
|
|
* calendar system type.
|
|
*
|
|
* @param id the chronology ID or calendar system type, not null
|
|
* @return the chronology with the identifier requested, or {@code null} if not found
|
|
*/
|
|
private static Chronology of0(String id) {
|
|
Chronology chrono = CHRONOS_BY_ID.get(id);
|
|
if (chrono == null) {
|
|
chrono = CHRONOS_BY_TYPE.get(id);
|
|
}
|
|
return chrono;
|
|
}
|
|
|
|
/**
|
|
* Returns the available chronologies.
|
|
* <p>
|
|
* Each returned {@code Chronology} is available for use in the system.
|
|
* The set of chronologies includes the system chronologies and
|
|
* any chronologies provided by the application via ServiceLoader
|
|
* configuration.
|
|
*
|
|
* @return the independent, modifiable set of the available chronology IDs, not null
|
|
*/
|
|
static Set<Chronology> getAvailableChronologies() {
|
|
initCache(); // force initialization
|
|
HashSet<Chronology> chronos = new HashSet<>(CHRONOS_BY_ID.values());
|
|
|
|
/// Add in Chronologies from the ServiceLoader configuration
|
|
@SuppressWarnings("rawtypes")
|
|
ServiceLoader<Chronology> loader = ServiceLoader.load(Chronology.class);
|
|
for (Chronology chrono : loader) {
|
|
chronos.add(chrono);
|
|
}
|
|
return chronos;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Creates an instance.
|
|
*/
|
|
protected AbstractChronology() {
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Resolves parsed {@code ChronoField} values into a date during parsing.
|
|
* <p>
|
|
* Most {@code TemporalField} implementations are resolved using the
|
|
* resolve method on the field. By contrast, the {@code ChronoField} class
|
|
* defines fields that only have meaning relative to the chronology.
|
|
* As such, {@code ChronoField} date fields are resolved here in the
|
|
* context of a specific chronology.
|
|
* <p>
|
|
* {@code ChronoField} instances are resolved by this method, which may
|
|
* be overridden in subclasses.
|
|
* <ul>
|
|
* <li>{@code EPOCH_DAY} - If present, this is converted to a date and
|
|
* all other date fields are then cross-checked against the date.
|
|
* <li>{@code PROLEPTIC_MONTH} - If present, then it is split into the
|
|
* {@code YEAR} and {@code MONTH_OF_YEAR}. If the mode is strict or smart
|
|
* then the field is validated.
|
|
* <li>{@code YEAR_OF_ERA} and {@code ERA} - If both are present, then they
|
|
* are combined to form a {@code YEAR}. In lenient mode, the {@code YEAR_OF_ERA}
|
|
* range is not validated, in smart and strict mode it is. The {@code ERA} is
|
|
* validated for range in all three modes. If only the {@code YEAR_OF_ERA} is
|
|
* present, and the mode is smart or lenient, then the last available era
|
|
* is assumed. In strict mode, no era is assumed and the {@code YEAR_OF_ERA} is
|
|
* left untouched. If only the {@code ERA} is present, then it is left untouched.
|
|
* <li>{@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} -
|
|
* If all three are present, then they are combined to form a date.
|
|
* In all three modes, the {@code YEAR} is validated.
|
|
* If the mode is smart or strict, then the month and day are validated.
|
|
* If the mode is lenient, then the date is combined in a manner equivalent to
|
|
* creating a date on the first day of the first month in the requested year,
|
|
* then adding the difference in months, then the difference in days.
|
|
* If the mode is smart, and the day-of-month is greater than the maximum for
|
|
* the year-month, then the day-of-month is adjusted to the last day-of-month.
|
|
* If the mode is strict, then the three fields must form a valid date.
|
|
* <li>{@code YEAR} and {@code DAY_OF_YEAR} -
|
|
* If both are present, then they are combined to form a date.
|
|
* In all three modes, the {@code YEAR} is validated.
|
|
* If the mode is lenient, then the date is combined in a manner equivalent to
|
|
* creating a date on the first day of the requested year, then adding
|
|
* the difference in days.
|
|
* If the mode is smart or strict, then the two fields must form a valid date.
|
|
* <li>{@code YEAR}, {@code MONTH_OF_YEAR}, {@code ALIGNED_WEEK_OF_MONTH} and
|
|
* {@code ALIGNED_DAY_OF_WEEK_IN_MONTH} -
|
|
* If all four are present, then they are combined to form a date.
|
|
* In all three modes, the {@code YEAR} is validated.
|
|
* If the mode is lenient, then the date is combined in a manner equivalent to
|
|
* creating a date on the first day of the first month in the requested year, then adding
|
|
* the difference in months, then the difference in weeks, then in days.
|
|
* If the mode is smart or strict, then the all four fields are validated to
|
|
* their outer ranges. The date is then combined in a manner equivalent to
|
|
* creating a date on the first day of the requested year and month, then adding
|
|
* the amount in weeks and days to reach their values. If the mode is strict,
|
|
* the date is additionally validated to check that the day and week adjustment
|
|
* did not change the month.
|
|
* <li>{@code YEAR}, {@code MONTH_OF_YEAR}, {@code ALIGNED_WEEK_OF_MONTH} and
|
|
* {@code DAY_OF_WEEK} - If all four are present, then they are combined to
|
|
* form a date. The approach is the same as described above for
|
|
* years, months and weeks in {@code ALIGNED_DAY_OF_WEEK_IN_MONTH}.
|
|
* The day-of-week is adjusted as the next or same matching day-of-week once
|
|
* the years, months and weeks have been handled.
|
|
* <li>{@code YEAR}, {@code ALIGNED_WEEK_OF_YEAR} and {@code ALIGNED_DAY_OF_WEEK_IN_YEAR} -
|
|
* If all three are present, then they are combined to form a date.
|
|
* In all three modes, the {@code YEAR} is validated.
|
|
* If the mode is lenient, then the date is combined in a manner equivalent to
|
|
* creating a date on the first day of the requested year, then adding
|
|
* the difference in weeks, then in days.
|
|
* If the mode is smart or strict, then the all three fields are validated to
|
|
* their outer ranges. The date is then combined in a manner equivalent to
|
|
* creating a date on the first day of the requested year, then adding
|
|
* the amount in weeks and days to reach their values. If the mode is strict,
|
|
* the date is additionally validated to check that the day and week adjustment
|
|
* did not change the year.
|
|
* <li>{@code YEAR}, {@code ALIGNED_WEEK_OF_YEAR} and {@code DAY_OF_WEEK} -
|
|
* If all three are present, then they are combined to form a date.
|
|
* The approach is the same as described above for years and weeks in
|
|
* {@code ALIGNED_DAY_OF_WEEK_IN_YEAR}. The day-of-week is adjusted as the
|
|
* next or same matching day-of-week once the years and weeks have been handled.
|
|
* </ul>
|
|
* <p>
|
|
* The default implementation is suitable for most calendar systems.
|
|
* If {@link java.time.temporal.ChronoField#YEAR_OF_ERA} is found without an {@link java.time.temporal.ChronoField#ERA}
|
|
* then the last era in {@link #eras()} is used.
|
|
* The implementation assumes a 7 day week, that the first day-of-month
|
|
* has the value 1, that first day-of-year has the value 1, and that the
|
|
* first of the month and year always exists.
|
|
*
|
|
* @param fieldValues the map of fields to values, which can be updated, not null
|
|
* @param resolverStyle the requested type of resolve, not null
|
|
* @return the resolved date, null if insufficient information to create a date
|
|
* @throws java.time.DateTimeException if the date cannot be resolved, typically
|
|
* because of a conflict in the input data
|
|
*/
|
|
@Override
|
|
public ChronoLocalDate resolveDate(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
// check epoch-day before inventing era
|
|
if (fieldValues.containsKey(EPOCH_DAY)) {
|
|
return dateEpochDay(fieldValues.remove(EPOCH_DAY));
|
|
}
|
|
|
|
// fix proleptic month before inventing era
|
|
resolveProlepticMonth(fieldValues, resolverStyle);
|
|
|
|
// invent era if necessary to resolve year-of-era
|
|
ChronoLocalDate resolved = resolveYearOfEra(fieldValues, resolverStyle);
|
|
if (resolved != null) {
|
|
return resolved;
|
|
}
|
|
|
|
// build date
|
|
if (fieldValues.containsKey(YEAR)) {
|
|
if (fieldValues.containsKey(MONTH_OF_YEAR)) {
|
|
if (fieldValues.containsKey(DAY_OF_MONTH)) {
|
|
return resolveYMD(fieldValues, resolverStyle);
|
|
}
|
|
if (fieldValues.containsKey(ALIGNED_WEEK_OF_MONTH)) {
|
|
if (fieldValues.containsKey(ALIGNED_DAY_OF_WEEK_IN_MONTH)) {
|
|
return resolveYMAA(fieldValues, resolverStyle);
|
|
}
|
|
if (fieldValues.containsKey(DAY_OF_WEEK)) {
|
|
return resolveYMAD(fieldValues, resolverStyle);
|
|
}
|
|
}
|
|
}
|
|
if (fieldValues.containsKey(DAY_OF_YEAR)) {
|
|
return resolveYD(fieldValues, resolverStyle);
|
|
}
|
|
if (fieldValues.containsKey(ALIGNED_WEEK_OF_YEAR)) {
|
|
if (fieldValues.containsKey(ALIGNED_DAY_OF_WEEK_IN_YEAR)) {
|
|
return resolveYAA(fieldValues, resolverStyle);
|
|
}
|
|
if (fieldValues.containsKey(DAY_OF_WEEK)) {
|
|
return resolveYAD(fieldValues, resolverStyle);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void resolveProlepticMonth(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
Long pMonth = fieldValues.remove(PROLEPTIC_MONTH);
|
|
if (pMonth != null) {
|
|
if (resolverStyle != ResolverStyle.LENIENT) {
|
|
PROLEPTIC_MONTH.checkValidValue(pMonth);
|
|
}
|
|
// first day-of-month is likely to be safest for setting proleptic-month
|
|
// cannot add to year zero, as not all chronologies have a year zero
|
|
ChronoLocalDate chronoDate = dateNow()
|
|
.with(DAY_OF_MONTH, 1).with(PROLEPTIC_MONTH, pMonth);
|
|
addFieldValue(fieldValues, MONTH_OF_YEAR, chronoDate.get(MONTH_OF_YEAR));
|
|
addFieldValue(fieldValues, YEAR, chronoDate.get(YEAR));
|
|
}
|
|
}
|
|
|
|
ChronoLocalDate resolveYearOfEra(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
Long yoeLong = fieldValues.remove(YEAR_OF_ERA);
|
|
if (yoeLong != null) {
|
|
Long eraLong = fieldValues.remove(ERA);
|
|
int yoe;
|
|
if (resolverStyle != ResolverStyle.LENIENT) {
|
|
yoe = range(YEAR_OF_ERA).checkValidIntValue(yoeLong, YEAR_OF_ERA);
|
|
} else {
|
|
yoe = Math.toIntExact(yoeLong);
|
|
}
|
|
if (eraLong != null) {
|
|
Era eraObj = eraOf(range(ERA).checkValidIntValue(eraLong, ERA));
|
|
addFieldValue(fieldValues, YEAR, prolepticYear(eraObj, yoe));
|
|
} else {
|
|
if (fieldValues.containsKey(YEAR)) {
|
|
int year = range(YEAR).checkValidIntValue(fieldValues.get(YEAR), YEAR);
|
|
ChronoLocalDate chronoDate = dateYearDay(year, 1);
|
|
addFieldValue(fieldValues, YEAR, prolepticYear(chronoDate.getEra(), yoe));
|
|
} else if (resolverStyle == ResolverStyle.STRICT) {
|
|
// do not invent era if strict
|
|
// reinstate the field removed earlier, no cross-check issues
|
|
fieldValues.put(YEAR_OF_ERA, yoeLong);
|
|
} else {
|
|
List<Era> eras = eras();
|
|
if (eras.isEmpty()) {
|
|
addFieldValue(fieldValues, YEAR, yoe);
|
|
} else {
|
|
Era eraObj = eras.get(eras.size() - 1);
|
|
addFieldValue(fieldValues, YEAR, prolepticYear(eraObj, yoe));
|
|
}
|
|
}
|
|
}
|
|
} else if (fieldValues.containsKey(ERA)) {
|
|
range(ERA).checkValidValue(fieldValues.get(ERA), ERA); // always validated
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ChronoLocalDate resolveYMD(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long months = Math.subtractExact(fieldValues.remove(MONTH_OF_YEAR), 1);
|
|
long days = Math.subtractExact(fieldValues.remove(DAY_OF_MONTH), 1);
|
|
return date(y, 1, 1).plus(months, MONTHS).plus(days, DAYS);
|
|
}
|
|
int moy = range(MONTH_OF_YEAR).checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR), MONTH_OF_YEAR);
|
|
ValueRange domRange = range(DAY_OF_MONTH);
|
|
int dom = domRange.checkValidIntValue(fieldValues.remove(DAY_OF_MONTH), DAY_OF_MONTH);
|
|
if (resolverStyle == ResolverStyle.SMART) { // previous valid
|
|
try {
|
|
return date(y, moy, dom);
|
|
} catch (DateTimeException ex) {
|
|
return date(y, moy, 1).with(TemporalAdjusters.lastDayOfMonth());
|
|
}
|
|
}
|
|
return date(y, moy, dom);
|
|
}
|
|
|
|
ChronoLocalDate resolveYD(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long days = Math.subtractExact(fieldValues.remove(DAY_OF_YEAR), 1);
|
|
return dateYearDay(y, 1).plus(days, DAYS);
|
|
}
|
|
int doy = range(DAY_OF_YEAR).checkValidIntValue(fieldValues.remove(DAY_OF_YEAR), DAY_OF_YEAR);
|
|
return dateYearDay(y, doy); // smart is same as strict
|
|
}
|
|
|
|
ChronoLocalDate resolveYMAA(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long months = Math.subtractExact(fieldValues.remove(MONTH_OF_YEAR), 1);
|
|
long weeks = Math.subtractExact(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), 1);
|
|
long days = Math.subtractExact(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_MONTH), 1);
|
|
return date(y, 1, 1).plus(months, MONTHS).plus(weeks, WEEKS).plus(days, DAYS);
|
|
}
|
|
int moy = range(MONTH_OF_YEAR).checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR), MONTH_OF_YEAR);
|
|
int aw = range(ALIGNED_WEEK_OF_MONTH).checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), ALIGNED_WEEK_OF_MONTH);
|
|
int ad = range(ALIGNED_DAY_OF_WEEK_IN_MONTH).checkValidIntValue(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_MONTH), ALIGNED_DAY_OF_WEEK_IN_MONTH);
|
|
ChronoLocalDate date = date(y, moy, 1).plus((aw - 1) * 7 + (ad - 1), DAYS);
|
|
if (resolverStyle == ResolverStyle.STRICT && date.get(MONTH_OF_YEAR) != moy) {
|
|
throw new DateTimeException("Strict mode rejected resolved date as it is in a different month");
|
|
}
|
|
return date;
|
|
}
|
|
|
|
ChronoLocalDate resolveYMAD(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long months = Math.subtractExact(fieldValues.remove(MONTH_OF_YEAR), 1);
|
|
long weeks = Math.subtractExact(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), 1);
|
|
long dow = Math.subtractExact(fieldValues.remove(DAY_OF_WEEK), 1);
|
|
return resolveAligned(date(y, 1, 1), months, weeks, dow);
|
|
}
|
|
int moy = range(MONTH_OF_YEAR).checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR), MONTH_OF_YEAR);
|
|
int aw = range(ALIGNED_WEEK_OF_MONTH).checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), ALIGNED_WEEK_OF_MONTH);
|
|
int dow = range(DAY_OF_WEEK).checkValidIntValue(fieldValues.remove(DAY_OF_WEEK), DAY_OF_WEEK);
|
|
ChronoLocalDate date = date(y, moy, 1).plus((aw - 1) * 7, DAYS).with(nextOrSame(DayOfWeek.of(dow)));
|
|
if (resolverStyle == ResolverStyle.STRICT && date.get(MONTH_OF_YEAR) != moy) {
|
|
throw new DateTimeException("Strict mode rejected resolved date as it is in a different month");
|
|
}
|
|
return date;
|
|
}
|
|
|
|
ChronoLocalDate resolveYAA(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long weeks = Math.subtractExact(fieldValues.remove(ALIGNED_WEEK_OF_YEAR), 1);
|
|
long days = Math.subtractExact(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_YEAR), 1);
|
|
return dateYearDay(y, 1).plus(weeks, WEEKS).plus(days, DAYS);
|
|
}
|
|
int aw = range(ALIGNED_WEEK_OF_YEAR).checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_YEAR), ALIGNED_WEEK_OF_YEAR);
|
|
int ad = range(ALIGNED_DAY_OF_WEEK_IN_YEAR).checkValidIntValue(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_YEAR), ALIGNED_DAY_OF_WEEK_IN_YEAR);
|
|
ChronoLocalDate date = dateYearDay(y, 1).plus((aw - 1) * 7 + (ad - 1), DAYS);
|
|
if (resolverStyle == ResolverStyle.STRICT && date.get(YEAR) != y) {
|
|
throw new DateTimeException("Strict mode rejected resolved date as it is in a different year");
|
|
}
|
|
return date;
|
|
}
|
|
|
|
ChronoLocalDate resolveYAD(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
|
|
int y = range(YEAR).checkValidIntValue(fieldValues.remove(YEAR), YEAR);
|
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
|
long weeks = Math.subtractExact(fieldValues.remove(ALIGNED_WEEK_OF_YEAR), 1);
|
|
long dow = Math.subtractExact(fieldValues.remove(DAY_OF_WEEK), 1);
|
|
return resolveAligned(dateYearDay(y, 1), 0, weeks, dow);
|
|
}
|
|
int aw = range(ALIGNED_WEEK_OF_YEAR).checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_YEAR), ALIGNED_WEEK_OF_YEAR);
|
|
int dow = range(DAY_OF_WEEK).checkValidIntValue(fieldValues.remove(DAY_OF_WEEK), DAY_OF_WEEK);
|
|
ChronoLocalDate date = dateYearDay(y, 1).plus((aw - 1) * 7, DAYS).with(nextOrSame(DayOfWeek.of(dow)));
|
|
if (resolverStyle == ResolverStyle.STRICT && date.get(YEAR) != y) {
|
|
throw new DateTimeException("Strict mode rejected resolved date as it is in a different year");
|
|
}
|
|
return date;
|
|
}
|
|
|
|
ChronoLocalDate resolveAligned(ChronoLocalDate base, long months, long weeks, long dow) {
|
|
ChronoLocalDate date = base.plus(months, MONTHS).plus(weeks, WEEKS);
|
|
if (dow > 7) {
|
|
date = date.plus((dow - 1) / 7, WEEKS);
|
|
dow = ((dow - 1) % 7) + 1;
|
|
} else if (dow < 1) {
|
|
date = date.plus(Math.subtractExact(dow, 7) / 7, WEEKS);
|
|
dow = ((dow + 6) % 7) + 1;
|
|
}
|
|
return date.with(nextOrSame(DayOfWeek.of((int) dow)));
|
|
}
|
|
|
|
/**
|
|
* Adds a field-value pair to the map, checking for conflicts.
|
|
* <p>
|
|
* If the field is not already present, then the field-value pair is added to the map.
|
|
* If the field is already present and it has the same value as that specified, no action occurs.
|
|
* If the field is already present and it has a different value to that specified, then
|
|
* an exception is thrown.
|
|
*
|
|
* @param field the field to add, not null
|
|
* @param value the value to add, not null
|
|
* @throws java.time.DateTimeException if the field is already present with a different value
|
|
*/
|
|
void addFieldValue(Map<TemporalField, Long> fieldValues, ChronoField field, long value) {
|
|
Long old = fieldValues.get(field); // check first for better error message
|
|
if (old != null && old.longValue() != value) {
|
|
throw new DateTimeException("Conflict found: " + field + " " + old + " differs from " + field + " " + value);
|
|
}
|
|
fieldValues.put(field, value);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Compares this chronology to another chronology.
|
|
* <p>
|
|
* The comparison order first by the chronology ID string, then by any
|
|
* additional information specific to the subclass.
|
|
* It is "consistent with equals", as defined by {@link Comparable}.
|
|
*
|
|
* @implSpec
|
|
* This implementation compares the chronology ID.
|
|
* Subclasses must compare any additional state that they store.
|
|
*
|
|
* @param other the other chronology to compare to, not null
|
|
* @return the comparator value, negative if less, positive if greater
|
|
*/
|
|
@Override
|
|
public int compareTo(Chronology other) {
|
|
return getId().compareTo(other.getId());
|
|
}
|
|
|
|
/**
|
|
* Checks if this chronology is equal to another chronology.
|
|
* <p>
|
|
* The comparison is based on the entire state of the object.
|
|
*
|
|
* @implSpec
|
|
* This implementation checks the type and calls
|
|
* {@link #compareTo(java.time.chrono.Chronology)}.
|
|
*
|
|
* @param obj the object to check, null returns false
|
|
* @return true if this is equal to the other chronology
|
|
*/
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj instanceof AbstractChronology) {
|
|
return compareTo((AbstractChronology) obj) == 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* A hash code for this chronology.
|
|
* <p>
|
|
* The hash code should be based on the entire state of the object.
|
|
*
|
|
* @implSpec
|
|
* This implementation is based on the chronology ID and class.
|
|
* Subclasses should add any additional state that they store.
|
|
*
|
|
* @return a suitable hash code
|
|
*/
|
|
@Override
|
|
public int hashCode() {
|
|
return getClass().hashCode() ^ getId().hashCode();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Outputs this chronology as a {@code String}, using the chronology ID.
|
|
*
|
|
* @return a string representation of this chronology, not null
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
return getId();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Writes the Chronology using a
|
|
* <a href="{@docRoot}/serialized-form.html#java.time.chrono.Ser">dedicated serialized form</a>.
|
|
* <pre>
|
|
* out.writeByte(1); // identifies this as a Chronology
|
|
* out.writeUTF(getId());
|
|
* </pre>
|
|
*
|
|
* @return the instance of {@code Ser}, not null
|
|
*/
|
|
@java.io.Serial
|
|
Object writeReplace() {
|
|
return new Ser(Ser.CHRONO_TYPE, (Serializable)this);
|
|
}
|
|
|
|
/**
|
|
* Defend against malicious streams.
|
|
*
|
|
* @param s the stream to read
|
|
* @throws java.io.InvalidObjectException always
|
|
*/
|
|
@java.io.Serial
|
|
private void readObject(ObjectInputStream s) throws ObjectStreamException {
|
|
throw new InvalidObjectException("Deserialization via serialization delegate");
|
|
}
|
|
|
|
void writeExternal(DataOutput out) throws IOException {
|
|
out.writeUTF(getId());
|
|
}
|
|
|
|
static Chronology readExternal(DataInput in) throws IOException {
|
|
String id = in.readUTF();
|
|
return Chronology.of(id);
|
|
}
|
|
|
|
}
|