/*
* Copyright (c) 2012, 2013, 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.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 {
/**
* ChronoLocalDate order constant.
*/
static final
Comparator<
ChronoLocalDate>
DATE_ORDER =
(
Comparator<
ChronoLocalDate> &
Serializable) (
date1,
date2) -> {
return
Long.
compare(
date1.
toEpochDay(),
date2.
toEpochDay());
};
/**
* ChronoLocalDateTime order constant.
*/
static final
Comparator<
ChronoLocalDateTime<? extends
ChronoLocalDate>>
DATE_TIME_ORDER =
(
Comparator<
ChronoLocalDateTime<? extends
ChronoLocalDate>> &
Serializable) (
dateTime1,
dateTime2) -> {
int
cmp =
Long.
compare(
dateTime1.
toLocalDate().
toEpochDay(),
dateTime2.
toLocalDate().
toEpochDay());
if (
cmp == 0) {
cmp =
Long.
compare(
dateTime1.
toLocalTime().
toNanoOfDay(),
dateTime2.
toLocalTime().
toNanoOfDay());
}
return
cmp;
};
/**
* ChronoZonedDateTime order constant.
*/
static final
Comparator<
ChronoZonedDateTime<?>>
INSTANT_ORDER =
(
Comparator<
ChronoZonedDateTime<?>> &
Serializable) (
dateTime1,
dateTime2) -> {
int
cmp =
Long.
compare(
dateTime1.
toEpochSecond(),
dateTime2.
toEpochSecond());
if (
cmp == 0) {
cmp =
Long.
compare(
dateTime1.
toLocalTime().
getNano(),
dateTime2.
toLocalTime().
getNano());
}
return
cmp;
};
/**
* 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="../../../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
*/
Object writeReplace() {
return new
Ser(
Ser.
CHRONO_TYPE, this);
}
/**
* Defend against malicious streams.
*
* @param s the stream to read
* @throws java.io.InvalidObjectException always
*/
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);
}
}