| /* | |
| * 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. | |
| */ | |
| /* | |
| * Copyright (c) 2011-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.temporal; | |
| import android.icu.text.DateTimePatternGenerator; | |
| import android.icu.util.ULocale; | |
| import static java.time.DayOfWeek.THURSDAY; | |
| import static java.time.DayOfWeek.WEDNESDAY; | |
| 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.MONTH_OF_YEAR; | |
| import static java.time.temporal.ChronoField.YEAR; | |
| import static java.time.temporal.ChronoUnit.DAYS; | |
| import static java.time.temporal.ChronoUnit.FOREVER; | |
| import static java.time.temporal.ChronoUnit.MONTHS; | |
| import static java.time.temporal.ChronoUnit.WEEKS; | |
| import static java.time.temporal.ChronoUnit.YEARS; | |
| import java.time.DateTimeException; | |
| import java.time.Duration; | |
| import java.time.LocalDate; | |
| import java.time.chrono.ChronoLocalDate; | |
| import java.time.chrono.Chronology; | |
| import java.time.chrono.IsoChronology; | |
| import java.time.format.ResolverStyle; | |
| import java.util.Locale; | |
| import java.util.Map; | |
| import java.util.Objects; | |
| import java.util.ResourceBundle; | |
| import sun.util.locale.provider.CalendarDataUtility; | |
| /** | |
| * Fields and units specific to the ISO-8601 calendar system, | |
| * including quarter-of-year and week-based-year. | |
| * <p> | |
| * This class defines fields and units that are specific to the ISO calendar system. | |
| * | |
| * <h2>Quarter of year</h2> | |
| * The ISO-8601 standard is based on the standard civic 12 month year. | |
| * This is commonly divided into four quarters, often abbreviated as Q1, Q2, Q3 and Q4. | |
| * <p> | |
| * January, February and March are in Q1. | |
| * April, May and June are in Q2. | |
| * July, August and September are in Q3. | |
| * October, November and December are in Q4. | |
| * <p> | |
| * The complete date is expressed using three fields: | |
| * <ul> | |
| * <li>{@link #DAY_OF_QUARTER DAY_OF_QUARTER} - the day within the quarter, from 1 to 90, 91 or 92 | |
| * <li>{@link #QUARTER_OF_YEAR QUARTER_OF_YEAR} - the quarter within the year, from 1 to 4 | |
| * <li>{@link ChronoField#YEAR YEAR} - the standard ISO year | |
| * </ul> | |
| * | |
| * <h2>Week based years</h2> | |
| * The ISO-8601 standard was originally intended as a data interchange format, | |
| * defining a string format for dates and times. However, it also defines an | |
| * alternate way of expressing the date, based on the concept of week-based-year. | |
| * <p> | |
| * The date is expressed using three fields: | |
| * <ul> | |
| * <li>{@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} - the standard field defining the | |
| * day-of-week from Monday (1) to Sunday (7) | |
| * <li>{@link #WEEK_OF_WEEK_BASED_YEAR} - the week within the week-based-year | |
| * <li>{@link #WEEK_BASED_YEAR WEEK_BASED_YEAR} - the week-based-year | |
| * </ul> | |
| * The week-based-year itself is defined relative to the standard ISO proleptic year. | |
| * It differs from the standard year in that it always starts on a Monday. | |
| * <p> | |
| * The first week of a week-based-year is the first Monday-based week of the standard | |
| * ISO year that has at least 4 days in the new year. | |
| * <ul> | |
| * <li>If January 1st is Monday then week 1 starts on January 1st | |
| * <li>If January 1st is Tuesday then week 1 starts on December 31st of the previous standard year | |
| * <li>If January 1st is Wednesday then week 1 starts on December 30th of the previous standard year | |
| * <li>If January 1st is Thursday then week 1 starts on December 29th of the previous standard year | |
| * <li>If January 1st is Friday then week 1 starts on January 4th | |
| * <li>If January 1st is Saturday then week 1 starts on January 3rd | |
| * <li>If January 1st is Sunday then week 1 starts on January 2nd | |
| * </ul> | |
| * There are 52 weeks in most week-based years, however on occasion there are 53 weeks. | |
| * <p> | |
| * For example: | |
| * | |
| * <table class=striped style="text-align: left"> | |
| * <caption>Examples of Week based Years</caption> | |
| * <thead> | |
| * <tr><th scope="col">Date</th><th scope="col">Day-of-week</th><th scope="col">Field values</th></tr> | |
| * </thead> | |
| * <tbody> | |
| * <tr><th scope="row">2008-12-28</th><td>Sunday</td><td>Week 52 of week-based-year 2008</td></tr> | |
| * <tr><th scope="row">2008-12-29</th><td>Monday</td><td>Week 1 of week-based-year 2009</td></tr> | |
| * <tr><th scope="row">2008-12-31</th><td>Wednesday</td><td>Week 1 of week-based-year 2009</td></tr> | |
| * <tr><th scope="row">2009-01-01</th><td>Thursday</td><td>Week 1 of week-based-year 2009</td></tr> | |
| * <tr><th scope="row">2009-01-04</th><td>Sunday</td><td>Week 1 of week-based-year 2009</td></tr> | |
| * <tr><th scope="row">2009-01-05</th><td>Monday</td><td>Week 2 of week-based-year 2009</td></tr> | |
| * </tbody> | |
| * </table> | |
| * | |
| * @implSpec | |
| * <p> | |
| * This class is immutable and thread-safe. | |
| * | |
| * @since 1.8 | |
| */ | |
| public final class IsoFields { | |
| /** | |
| * The field that represents the day-of-quarter. | |
| * <p> | |
| * This field allows the day-of-quarter value to be queried and set. | |
| * The day-of-quarter has values from 1 to 90 in Q1 of a standard year, from 1 to 91 | |
| * in Q1 of a leap year, from 1 to 91 in Q2 and from 1 to 92 in Q3 and Q4. | |
| * <p> | |
| * The day-of-quarter can only be calculated if the day-of-year, month-of-year and year | |
| * are available. | |
| * <p> | |
| * When setting this field, the value is allowed to be partially lenient, taking any | |
| * value from 1 to 92. If the quarter has less than 92 days, then day 92, and | |
| * potentially day 91, is in the following quarter. | |
| * <p> | |
| * In the resolving phase of parsing, a date can be created from a year, | |
| * quarter-of-year and day-of-quarter. | |
| * <p> | |
| * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are | |
| * validated against their range of valid values. The day-of-quarter field | |
| * is validated from 1 to 90, 91 or 92 depending on the year and quarter. | |
| * <p> | |
| * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are | |
| * validated against their range of valid values. The day-of-quarter field is | |
| * validated between 1 and 92, ignoring the actual range based on the year and quarter. | |
| * If the day-of-quarter exceeds the actual range by one day, then the resulting date | |
| * is one day later. If the day-of-quarter exceeds the actual range by two days, | |
| * then the resulting date is two days later. | |
| * <p> | |
| * In {@linkplain ResolverStyle#LENIENT lenient mode}, only the year is validated | |
| * against the range of valid values. The resulting date is calculated equivalent to | |
| * the following three stage approach. First, create a date on the first of January | |
| * in the requested year. Then take the quarter-of-year, subtract one, and add the | |
| * amount in quarters to the date. Finally, take the day-of-quarter, subtract one, | |
| * and add the amount in days to the date. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalField DAY_OF_QUARTER = Field.DAY_OF_QUARTER; | |
| /** | |
| * The field that represents the quarter-of-year. | |
| * <p> | |
| * This field allows the quarter-of-year value to be queried and set. | |
| * The quarter-of-year has values from 1 to 4. | |
| * <p> | |
| * The quarter-of-year can only be calculated if the month-of-year is available. | |
| * <p> | |
| * In the resolving phase of parsing, a date can be created from a year, | |
| * quarter-of-year and day-of-quarter. | |
| * See {@link #DAY_OF_QUARTER} for details. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalField QUARTER_OF_YEAR = Field.QUARTER_OF_YEAR; | |
| /** | |
| * The field that represents the week-of-week-based-year. | |
| * <p> | |
| * This field allows the week of the week-based-year value to be queried and set. | |
| * The week-of-week-based-year has values from 1 to 52, or 53 if the | |
| * week-based-year has 53 weeks. | |
| * <p> | |
| * In the resolving phase of parsing, a date can be created from a | |
| * week-based-year, week-of-week-based-year and day-of-week. | |
| * <p> | |
| * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are | |
| * validated against their range of valid values. The week-of-week-based-year | |
| * field is validated from 1 to 52 or 53 depending on the week-based-year. | |
| * <p> | |
| * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are | |
| * validated against their range of valid values. The week-of-week-based-year | |
| * field is validated between 1 and 53, ignoring the week-based-year. | |
| * If the week-of-week-based-year is 53, but the week-based-year only has | |
| * 52 weeks, then the resulting date is in week 1 of the following week-based-year. | |
| * <p> | |
| * In {@linkplain ResolverStyle#LENIENT lenient mode}, only the week-based-year | |
| * is validated against the range of valid values. If the day-of-week is outside | |
| * the range 1 to 7, then the resulting date is adjusted by a suitable number of | |
| * weeks to reduce the day-of-week to the range 1 to 7. If the week-of-week-based-year | |
| * value is outside the range 1 to 52, then any excess weeks are added or subtracted | |
| * from the resulting date. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalField WEEK_OF_WEEK_BASED_YEAR = Field.WEEK_OF_WEEK_BASED_YEAR; | |
| /** | |
| * The field that represents the week-based-year. | |
| * <p> | |
| * This field allows the week-based-year value to be queried and set. | |
| * <p> | |
| * The field has a range that matches {@link LocalDate#MAX} and {@link LocalDate#MIN}. | |
| * <p> | |
| * In the resolving phase of parsing, a date can be created from a | |
| * week-based-year, week-of-week-based-year and day-of-week. | |
| * See {@link #WEEK_OF_WEEK_BASED_YEAR} for details. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalField WEEK_BASED_YEAR = Field.WEEK_BASED_YEAR; | |
| /** | |
| * The unit that represents week-based-years for the purpose of addition and subtraction. | |
| * <p> | |
| * This allows a number of week-based-years to be added to, or subtracted from, a date. | |
| * The unit is equal to either 52 or 53 weeks. | |
| * The estimated duration of a week-based-year is the same as that of a standard ISO | |
| * year at {@code 365.2425 Days}. | |
| * <p> | |
| * The rules for addition add the number of week-based-years to the existing value | |
| * for the week-based-year field. If the resulting week-based-year only has 52 weeks, | |
| * then the date will be in week 1 of the following week-based-year. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalUnit WEEK_BASED_YEARS = Unit.WEEK_BASED_YEARS; | |
| /** | |
| * Unit that represents the concept of a quarter-year. | |
| * For the ISO calendar system, it is equal to 3 months. | |
| * The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}. | |
| * <p> | |
| * This unit is an immutable and thread-safe singleton. | |
| */ | |
| public static final TemporalUnit QUARTER_YEARS = Unit.QUARTER_YEARS; | |
| /** | |
| * Restricted constructor. | |
| */ | |
| private IsoFields() { | |
| throw new AssertionError("Not instantiable"); | |
| } | |
| //----------------------------------------------------------------------- | |
| /** | |
| * Implementation of the field. | |
| */ | |
| private static enum Field implements TemporalField { | |
| DAY_OF_QUARTER { | |
| @Override | |
| public TemporalUnit getBaseUnit() { | |
| return DAYS; | |
| } | |
| @Override | |
| public TemporalUnit getRangeUnit() { | |
| return QUARTER_YEARS; | |
| } | |
| @Override | |
| public ValueRange range() { | |
| return ValueRange.of(1, 90, 92); | |
| } | |
| @Override | |
| public boolean isSupportedBy(TemporalAccessor temporal) { | |
| return temporal.isSupported(DAY_OF_YEAR) && temporal.isSupported(MONTH_OF_YEAR) && | |
| temporal.isSupported(YEAR) && isIso(temporal); | |
| } | |
| @Override | |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: DayOfQuarter"); | |
| } | |
| long qoy = temporal.getLong(QUARTER_OF_YEAR); | |
| if (qoy == 1) { | |
| long year = temporal.getLong(YEAR); | |
| return (IsoChronology.INSTANCE.isLeapYear(year) ? ValueRange.of(1, 91) : ValueRange.of(1, 90)); | |
| } else if (qoy == 2) { | |
| return ValueRange.of(1, 91); | |
| } else if (qoy == 3 || qoy == 4) { | |
| return ValueRange.of(1, 92); | |
| } // else value not from 1 to 4, so drop through | |
| return range(); | |
| } | |
| @Override | |
| public long getFrom(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: DayOfQuarter"); | |
| } | |
| int doy = temporal.get(DAY_OF_YEAR); | |
| int moy = temporal.get(MONTH_OF_YEAR); | |
| long year = temporal.getLong(YEAR); | |
| return doy - QUARTER_DAYS[((moy - 1) / 3) + (IsoChronology.INSTANCE.isLeapYear(year) ? 4 : 0)]; | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Override | |
| public <R extends Temporal> R adjustInto(R temporal, long newValue) { | |
| // calls getFrom() to check if supported | |
| long curValue = getFrom(temporal); | |
| range().checkValidValue(newValue, this); // leniently check from 1 to 92 TODO: check | |
| return (R) temporal.with(DAY_OF_YEAR, temporal.getLong(DAY_OF_YEAR) + (newValue - curValue)); | |
| } | |
| @Override | |
| public ChronoLocalDate resolve( | |
| Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) { | |
| Long yearLong = fieldValues.get(YEAR); | |
| Long qoyLong = fieldValues.get(QUARTER_OF_YEAR); | |
| if (yearLong == null || qoyLong == null) { | |
| return null; | |
| } | |
| int y = YEAR.checkValidIntValue(yearLong); // always validate | |
| long doq = fieldValues.get(DAY_OF_QUARTER); | |
| ensureIso(partialTemporal); | |
| LocalDate date; | |
| if (resolverStyle == ResolverStyle.LENIENT) { | |
| date = LocalDate.of(y, 1, 1).plusMonths(Math.multiplyExact(Math.subtractExact(qoyLong, 1), 3)); | |
| doq = Math.subtractExact(doq, 1); | |
| } else { | |
| int qoy = QUARTER_OF_YEAR.range().checkValidIntValue(qoyLong, QUARTER_OF_YEAR); // validated | |
| date = LocalDate.of(y, ((qoy - 1) * 3) + 1, 1); | |
| if (doq < 1 || doq > 90) { | |
| if (resolverStyle == ResolverStyle.STRICT) { | |
| rangeRefinedBy(date).checkValidValue(doq, this); // only allow exact range | |
| } else { // SMART | |
| range().checkValidValue(doq, this); // allow 1-92 rolling into next quarter | |
| } | |
| } | |
| doq--; | |
| } | |
| fieldValues.remove(this); | |
| fieldValues.remove(YEAR); | |
| fieldValues.remove(QUARTER_OF_YEAR); | |
| return date.plusDays(doq); | |
| } | |
| @Override | |
| public String toString() { | |
| return "DayOfQuarter"; | |
| } | |
| }, | |
| QUARTER_OF_YEAR { | |
| @Override | |
| public TemporalUnit getBaseUnit() { | |
| return QUARTER_YEARS; | |
| } | |
| @Override | |
| public TemporalUnit getRangeUnit() { | |
| return YEARS; | |
| } | |
| @Override | |
| public ValueRange range() { | |
| return ValueRange.of(1, 4); | |
| } | |
| @Override | |
| public boolean isSupportedBy(TemporalAccessor temporal) { | |
| return temporal.isSupported(MONTH_OF_YEAR) && isIso(temporal); | |
| } | |
| @Override | |
| public long getFrom(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: QuarterOfYear"); | |
| } | |
| long moy = temporal.getLong(MONTH_OF_YEAR); | |
| return ((moy + 2) / 3); | |
| } | |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: QuarterOfYear"); | |
| } | |
| return super.rangeRefinedBy(temporal); | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Override | |
| public <R extends Temporal> R adjustInto(R temporal, long newValue) { | |
| // calls getFrom() to check if supported | |
| long curValue = getFrom(temporal); | |
| range().checkValidValue(newValue, this); // strictly check from 1 to 4 | |
| return (R) temporal.with(MONTH_OF_YEAR, temporal.getLong(MONTH_OF_YEAR) + (newValue - curValue) * 3); | |
| } | |
| @Override | |
| public String toString() { | |
| return "QuarterOfYear"; | |
| } | |
| }, | |
| WEEK_OF_WEEK_BASED_YEAR { | |
| @Override | |
| public String getDisplayName(Locale locale) { | |
| Objects.requireNonNull(locale, "locale"); | |
| // BEGIN Android-changed: Use ICU name values. | |
| /* | |
| LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased() | |
| .getLocaleResources( | |
| CalendarDataUtility | |
| .findRegionOverride(locale)); | |
| ResourceBundle rb = lr.getJavaTimeFormatData(); | |
| return rb.containsKey("field.week") ? rb.getString("field.week") : toString(); | |
| */ | |
| DateTimePatternGenerator dateTimePatternGenerator = DateTimePatternGenerator | |
| .getInstance(ULocale.forLocale(locale)); | |
| String icuName = dateTimePatternGenerator | |
| .getAppendItemName(DateTimePatternGenerator.WEEK_OF_YEAR); | |
| return icuName != null && !icuName.isEmpty() ? icuName : toString(); | |
| // END Android-changed: Use ICU name values. | |
| } | |
| @Override | |
| public TemporalUnit getBaseUnit() { | |
| return WEEKS; | |
| } | |
| @Override | |
| public TemporalUnit getRangeUnit() { | |
| return WEEK_BASED_YEARS; | |
| } | |
| @Override | |
| public ValueRange range() { | |
| return ValueRange.of(1, 52, 53); | |
| } | |
| @Override | |
| public boolean isSupportedBy(TemporalAccessor temporal) { | |
| return temporal.isSupported(EPOCH_DAY) && isIso(temporal); | |
| } | |
| @Override | |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: WeekOfWeekBasedYear"); | |
| } | |
| return getWeekRange(LocalDate.from(temporal)); | |
| } | |
| @Override | |
| public long getFrom(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: WeekOfWeekBasedYear"); | |
| } | |
| return getWeek(LocalDate.from(temporal)); | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Override | |
| public <R extends Temporal> R adjustInto(R temporal, long newValue) { | |
| // calls getFrom() to check if supported | |
| range().checkValidValue(newValue, this); // lenient range | |
| return (R) temporal.plus(Math.subtractExact(newValue, getFrom(temporal)), WEEKS); | |
| } | |
| @Override | |
| public ChronoLocalDate resolve( | |
| Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) { | |
| Long wbyLong = fieldValues.get(WEEK_BASED_YEAR); | |
| Long dowLong = fieldValues.get(DAY_OF_WEEK); | |
| if (wbyLong == null || dowLong == null) { | |
| return null; | |
| } | |
| int wby = WEEK_BASED_YEAR.range().checkValidIntValue(wbyLong, WEEK_BASED_YEAR); // always validate | |
| long wowby = fieldValues.get(WEEK_OF_WEEK_BASED_YEAR); | |
| ensureIso(partialTemporal); | |
| LocalDate date = LocalDate.of(wby, 1, 4); | |
| if (resolverStyle == ResolverStyle.LENIENT) { | |
| long dow = dowLong; // unvalidated | |
| if (dow > 7) { | |
| date = date.plusWeeks((dow - 1) / 7); | |
| dow = ((dow - 1) % 7) + 1; | |
| } else if (dow < 1) { | |
| date = date.plusWeeks(Math.subtractExact(dow, 7) / 7); | |
| dow = ((dow + 6) % 7) + 1; | |
| } | |
| date = date.plusWeeks(Math.subtractExact(wowby, 1)).with(DAY_OF_WEEK, dow); | |
| } else { | |
| int dow = DAY_OF_WEEK.checkValidIntValue(dowLong); // validated | |
| if (wowby < 1 || wowby > 52) { | |
| if (resolverStyle == ResolverStyle.STRICT) { | |
| getWeekRange(date).checkValidValue(wowby, this); // only allow exact range | |
| } else { // SMART | |
| range().checkValidValue(wowby, this); // allow 1-53 rolling into next year | |
| } | |
| } | |
| date = date.plusWeeks(wowby - 1).with(DAY_OF_WEEK, dow); | |
| } | |
| fieldValues.remove(this); | |
| fieldValues.remove(WEEK_BASED_YEAR); | |
| fieldValues.remove(DAY_OF_WEEK); | |
| return date; | |
| } | |
| @Override | |
| public String toString() { | |
| return "WeekOfWeekBasedYear"; | |
| } | |
| }, | |
| WEEK_BASED_YEAR { | |
| @Override | |
| public TemporalUnit getBaseUnit() { | |
| return WEEK_BASED_YEARS; | |
| } | |
| @Override | |
| public TemporalUnit getRangeUnit() { | |
| return FOREVER; | |
| } | |
| @Override | |
| public ValueRange range() { | |
| return YEAR.range(); | |
| } | |
| @Override | |
| public boolean isSupportedBy(TemporalAccessor temporal) { | |
| return temporal.isSupported(EPOCH_DAY) && isIso(temporal); | |
| } | |
| @Override | |
| public long getFrom(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: WeekBasedYear"); | |
| } | |
| return getWeekBasedYear(LocalDate.from(temporal)); | |
| } | |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: WeekBasedYear"); | |
| } | |
| return super.rangeRefinedBy(temporal); | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Override | |
| public <R extends Temporal> R adjustInto(R temporal, long newValue) { | |
| if (isSupportedBy(temporal) == false) { | |
| throw new UnsupportedTemporalTypeException("Unsupported field: WeekBasedYear"); | |
| } | |
| int newWby = range().checkValidIntValue(newValue, WEEK_BASED_YEAR); // strict check | |
| LocalDate date = LocalDate.from(temporal); | |
| int dow = date.get(DAY_OF_WEEK); | |
| int week = getWeek(date); | |
| if (week == 53 && getWeekRange(newWby) == 52) { | |
| week = 52; | |
| } | |
| LocalDate resolved = LocalDate.of(newWby, 1, 4); // 4th is guaranteed to be in week one | |
| int days = (dow - resolved.get(DAY_OF_WEEK)) + ((week - 1) * 7); | |
| resolved = resolved.plusDays(days); | |
| return (R) temporal.with(resolved); | |
| } | |
| @Override | |
| public String toString() { | |
| return "WeekBasedYear"; | |
| } | |
| }; | |
| @Override | |
| public boolean isDateBased() { | |
| return true; | |
| } | |
| @Override | |
| public boolean isTimeBased() { | |
| return false; | |
| } | |
| @Override | |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { | |
| return range(); | |
| } | |
| //------------------------------------------------------------------------- | |
| private static final int[] QUARTER_DAYS = {0, 90, 181, 273, 0, 91, 182, 274}; | |
| private static void ensureIso(TemporalAccessor temporal) { | |
| if (isIso(temporal) == false) { | |
| throw new DateTimeException("Resolve requires IsoChronology"); | |
| } | |
| } | |
| private static ValueRange getWeekRange(LocalDate date) { | |
| int wby = getWeekBasedYear(date); | |
| return ValueRange.of(1, getWeekRange(wby)); | |
| } | |
| private static int getWeekRange(int wby) { | |
| LocalDate date = LocalDate.of(wby, 1, 1); | |
| // 53 weeks if standard year starts on Thursday, or Wed in a leap year | |
| if (date.getDayOfWeek() == THURSDAY || (date.getDayOfWeek() == WEDNESDAY && date.isLeapYear())) { | |
| return 53; | |
| } | |
| return 52; | |
| } | |
| private static int getWeek(LocalDate date) { | |
| int dow0 = date.getDayOfWeek().ordinal(); | |
| int doy0 = date.getDayOfYear() - 1; | |
| int doyThu0 = doy0 + (3 - dow0); // adjust to mid-week Thursday (which is 3 indexed from zero) | |
| int alignedWeek = doyThu0 / 7; | |
| int firstThuDoy0 = doyThu0 - (alignedWeek * 7); | |
| int firstMonDoy0 = firstThuDoy0 - 3; | |
| if (firstMonDoy0 < -3) { | |
| firstMonDoy0 += 7; | |
| } | |
| if (doy0 < firstMonDoy0) { | |
| return (int) getWeekRange(date.withDayOfYear(180).minusYears(1)).getMaximum(); | |
| } | |
| int week = ((doy0 - firstMonDoy0) / 7) + 1; | |
| if (week == 53) { | |
| if ((firstMonDoy0 == -3 || (firstMonDoy0 == -2 && date.isLeapYear())) == false) { | |
| week = 1; | |
| } | |
| } | |
| return week; | |
| } | |
| private static int getWeekBasedYear(LocalDate date) { | |
| int year = date.getYear(); | |
| int doy = date.getDayOfYear(); | |
| if (doy <= 3) { | |
| int dow = date.getDayOfWeek().ordinal(); | |
| if (doy - dow < -2) { | |
| year--; | |
| } | |
| } else if (doy >= 363) { | |
| int dow = date.getDayOfWeek().ordinal(); | |
| doy = doy - 363 - (date.isLeapYear() ? 1 : 0); | |
| if (doy - dow >= 0) { | |
| year++; | |
| } | |
| } | |
| return year; | |
| } | |
| } | |
| //----------------------------------------------------------------------- | |
| /** | |
| * Implementation of the unit. | |
| */ | |
| private static enum Unit implements TemporalUnit { | |
| /** | |
| * Unit that represents the concept of a week-based-year. | |
| */ | |
| WEEK_BASED_YEARS("WeekBasedYears", Duration.ofSeconds(31556952L)), | |
| /** | |
| * Unit that represents the concept of a quarter-year. | |
| */ | |
| QUARTER_YEARS("QuarterYears", Duration.ofSeconds(31556952L / 4)); | |
| private final String name; | |
| private final Duration duration; | |
| private Unit(String name, Duration estimatedDuration) { | |
| this.name = name; | |
| this.duration = estimatedDuration; | |
| } | |
| @Override | |
| public Duration getDuration() { | |
| return duration; | |
| } | |
| @Override | |
| public boolean isDurationEstimated() { | |
| return true; | |
| } | |
| @Override | |
| public boolean isDateBased() { | |
| return true; | |
| } | |
| @Override | |
| public boolean isTimeBased() { | |
| return false; | |
| } | |
| @Override | |
| public boolean isSupportedBy(Temporal temporal) { | |
| return temporal.isSupported(EPOCH_DAY) && isIso(temporal); | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Override | |
| public <R extends Temporal> R addTo(R temporal, long amount) { | |
| switch (this) { | |
| case WEEK_BASED_YEARS: | |
| return (R) temporal.with(WEEK_BASED_YEAR, | |
| Math.addExact(temporal.get(WEEK_BASED_YEAR), amount)); | |
| case QUARTER_YEARS: | |
| return (R) temporal.plus(amount / 4, YEARS) | |
| .plus((amount % 4) * 3, MONTHS); | |
| default: | |
| throw new IllegalStateException("Unreachable"); | |
| } | |
| } | |
| @Override | |
| public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) { | |
| if (temporal1Inclusive.getClass() != temporal2Exclusive.getClass()) { | |
| return temporal1Inclusive.until(temporal2Exclusive, this); | |
| } | |
| switch(this) { | |
| case WEEK_BASED_YEARS: | |
| return Math.subtractExact(temporal2Exclusive.getLong(WEEK_BASED_YEAR), | |
| temporal1Inclusive.getLong(WEEK_BASED_YEAR)); | |
| case QUARTER_YEARS: | |
| return temporal1Inclusive.until(temporal2Exclusive, MONTHS) / 3; | |
| default: | |
| throw new IllegalStateException("Unreachable"); | |
| } | |
| } | |
| @Override | |
| public String toString() { | |
| return name; | |
| } | |
| } | |
| static boolean isIso(TemporalAccessor temporal) { | |
| return Chronology.from(temporal).equals(IsoChronology.INSTANCE); | |
| } | |
| } |