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/AbstractChronology.java
/* * 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 { /** * 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); } }
⏎ java/time/chrono/AbstractChronology.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, 203667👍, 0💬
Popular Posts:
JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time for...
JDK 11 java.management.jmod is the JMOD file for JDK 11 Management module. JDK 11 Management module ...
How to perform XML Schema validation with sax\Writer.java provided in the Apache Xerces package? You...
MP3SPI is a Java Service Provider Interface that adds MP3 (MPEG 1/2/2.5 Layer 1/2/3) audio format su...
The JDT project provides the tool plug-ins that implement a Java IDE supporting the development of a...