src/share/classes/java/time/temporal/IsoFields.java

Print this page




  55  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  56  */
  57 package java.time.temporal;
  58 
  59 import static java.time.DayOfWeek.THURSDAY;
  60 import static java.time.DayOfWeek.WEDNESDAY;
  61 import static java.time.temporal.ChronoField.DAY_OF_WEEK;
  62 import static java.time.temporal.ChronoField.DAY_OF_YEAR;
  63 import static java.time.temporal.ChronoField.EPOCH_DAY;
  64 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
  65 import static java.time.temporal.ChronoField.YEAR;
  66 import static java.time.temporal.ChronoUnit.DAYS;
  67 import static java.time.temporal.ChronoUnit.FOREVER;
  68 import static java.time.temporal.ChronoUnit.MONTHS;
  69 import static java.time.temporal.ChronoUnit.WEEKS;
  70 import static java.time.temporal.ChronoUnit.YEARS;
  71 
  72 import java.time.DateTimeException;
  73 import java.time.Duration;
  74 import java.time.LocalDate;
  75 import java.time.format.DateTimeBuilder;



  76 
  77 /**
  78  * Fields and units specific to the ISO-8601 calendar system,
  79  * including quarter-of-year and week-based-year.
  80  * <p>
  81  * This class defines fields and units that are specific to the ISO calendar system.
  82  *
  83  * <h3>Quarter of year</h3>
  84  * The ISO-8601 standard is based on the standard civic 12 month year.
  85  * This is commonly divided into four quarters, often abbreviated as Q1, Q2, Q3 and Q4.
  86  * <p>
  87  * January, February and March are in Q1.
  88  * April, May and June are in Q2.
  89  * July, August and September are in Q3.
  90  * October, November and December are in Q4.
  91  * <p>
  92  * The complete date is expressed using three fields:
  93  * <p><ul>
  94  * <li>{@link #DAY_OF_QUARTER DAY_OF_QUARTER} - the day within the quarter, from 1 to 90, 91 or 92
  95  * <li>{@link #QUARTER_OF_YEAR QUARTER_OF_YEAR} - the week within the week-based-year


 126  * <p>
 127  * For example:
 128  * <p>
 129  * <table cellpadding="0" cellspacing="3" border="0" style="text-align: left; width: 50%;">
 130  * <caption>Examples of Week based Years</caption>
 131  * <tr><th>Date</th><th>Day-of-week</th><th>Field values</th></tr>
 132  * <tr><th>2008-12-28</th><td>Sunday</td><td>Week 52 of week-based-year 2008</td></tr>
 133  * <tr><th>2008-12-29</th><td>Monday</td><td>Week 1 of week-based-year 2009</td></tr>
 134  * <tr><th>2008-12-31</th><td>Wednesday</td><td>Week 1 of week-based-year 2009</td></tr>
 135  * <tr><th>2009-01-01</th><td>Thursday</td><td>Week 1 of week-based-year 2009</td></tr>
 136  * <tr><th>2009-01-04</th><td>Sunday</td><td>Week 1 of week-based-year 2009</td></tr>
 137  * <tr><th>2009-01-05</th><td>Monday</td><td>Week 2 of week-based-year 2009</td></tr>
 138  * </table>
 139  *
 140  * <h3>Specification for implementors</h3>
 141  * <p>
 142  * This class is immutable and thread-safe.
 143  *
 144  * @since 1.8
 145  */
 146 public final class ISOFields {
 147 
 148     /**
 149      * The field that represents the day-of-quarter.
 150      * <p>
 151      * This field allows the day-of-quarter value to be queried and set.
 152      * The day-of-quarter has values from 1 to 90 in Q1 of a standard year, from 1 to 91
 153      * in Q1 of a leap year, from 1 to 91 in Q2 and from 1 to 92 in Q3 and Q4.
 154      * <p>
 155      * The day-of-quarter can only be calculated if the day-of-year, month-of-year and year
 156      * are available.
 157      * <p>
 158      * When setting this field, the value is allowed to be partially lenient, taking any
 159      * value from 1 to 92. If the quarter has less than 92 days, then day 92, and
 160      * potentially day 91, is in the following quarter.
 161      * <p>
 162      * This unit is an immutable and thread-safe singleton.
 163      */
 164     public static final TemporalField DAY_OF_QUARTER = Field.DAY_OF_QUARTER;
 165     /**
 166      * The field that represents the quarter-of-year.


 199      * <p>
 200      * The rules for addition add the number of week-based-years to the existing value
 201      * for the week-based-year field. If the resulting week-based-year only has 52 weeks,
 202      * then the date will be in week 1 of the following week-based-year.
 203      * <p>
 204      * This unit is an immutable and thread-safe singleton.
 205      */
 206     public static final TemporalUnit WEEK_BASED_YEARS = Unit.WEEK_BASED_YEARS;
 207     /**
 208      * Unit that represents the concept of a quarter-year.
 209      * For the ISO calendar system, it is equal to 3 months.
 210      * The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
 211      * <p>
 212      * This unit is an immutable and thread-safe singleton.
 213      */
 214     public static final TemporalUnit QUARTER_YEARS = Unit.QUARTER_YEARS;
 215 
 216     /**
 217      * Restricted constructor.
 218      */
 219     private ISOFields() {
 220         throw new AssertionError("Not instantiable");
 221     }
 222 
 223     //-----------------------------------------------------------------------
 224     /**
 225      * Implementation of the field.
 226      */
 227     private static enum Field implements TemporalField {
 228         DAY_OF_QUARTER {
 229             @Override
 230             public String getName() {
 231                 return "DayOfQuarter";
 232             }
 233             @Override
 234             public TemporalUnit getBaseUnit() {
 235                 return DAYS;
 236             }
 237             @Override
 238             public TemporalUnit getRangeUnit() {
 239                 return QUARTER_YEARS;
 240             }
 241             @Override
 242             public ValueRange range() {
 243                 return ValueRange.of(1, 90, 92);
 244             }
 245             @Override
 246             public boolean doIsSupported(TemporalAccessor temporal) {
 247                 return temporal.isSupported(DAY_OF_YEAR) && temporal.isSupported(MONTH_OF_YEAR) &&
 248                         temporal.isSupported(YEAR) && Chrono.from(temporal).equals(ISOChrono.INSTANCE);
 249             }
 250             @Override
 251             public ValueRange doRange(TemporalAccessor temporal) {
 252                 if (doIsSupported(temporal) == false) {
 253                     throw new DateTimeException("Unsupported field: DayOfQuarter");
 254                 }
 255                 long qoy = temporal.getLong(QUARTER_OF_YEAR);
 256                 if (qoy == 1) {
 257                     long year = temporal.getLong(YEAR);
 258                     return (ISOChrono.INSTANCE.isLeapYear(year) ? ValueRange.of(1, 91) : ValueRange.of(1, 90));
 259                 } else if (qoy == 2) {
 260                     return ValueRange.of(1, 91);
 261                 } else if (qoy == 3 || qoy == 4) {
 262                     return ValueRange.of(1, 92);
 263                 } // else value not from 1 to 4, so drop through
 264                 return range();
 265             }
 266             @Override
 267             public long doGet(TemporalAccessor temporal) {
 268                 if (doIsSupported(temporal) == false) {
 269                     throw new DateTimeException("Unsupported field: DayOfQuarter");
 270                 }
 271                 int doy = temporal.get(DAY_OF_YEAR);
 272                 int moy = temporal.get(MONTH_OF_YEAR);
 273                 long year = temporal.getLong(YEAR);
 274                 return doy - QUARTER_DAYS[((moy - 1) / 3) + (ISOChrono.INSTANCE.isLeapYear(year) ? 4 : 0)];
 275             }

 276             @Override
 277             public <R extends Temporal> R doWith(R temporal, long newValue) {
 278                 long curValue = doGet(temporal);
 279                 range().checkValidValue(newValue, this);

 280                 return (R) temporal.with(DAY_OF_YEAR, temporal.getLong(DAY_OF_YEAR) + (newValue - curValue));
 281             }















 282         },
 283         QUARTER_OF_YEAR {
 284             @Override
 285             public String getName() {
 286                 return "QuarterOfYear";
 287             }
 288             @Override
 289             public TemporalUnit getBaseUnit() {
 290                 return QUARTER_YEARS;
 291             }
 292             @Override
 293             public TemporalUnit getRangeUnit() {
 294                 return YEARS;
 295             }
 296             @Override
 297             public ValueRange range() {
 298                 return ValueRange.of(1, 4);
 299             }
 300             @Override
 301             public boolean doIsSupported(TemporalAccessor temporal) {
 302                 return temporal.isSupported(MONTH_OF_YEAR) && Chrono.from(temporal).equals(ISOChrono.INSTANCE);
 303             }
 304             @Override
 305             public long doGet(TemporalAccessor temporal) {
 306                 if (doIsSupported(temporal) == false) {
 307                     throw new DateTimeException("Unsupported field: DayOfQuarter");
 308                 }
 309                 long moy = temporal.getLong(MONTH_OF_YEAR);
 310                 return ((moy + 2) / 3);
 311             }

 312             @Override
 313             public <R extends Temporal> R doWith(R temporal, long newValue) {
 314                 long curValue = doGet(temporal);
 315                 range().checkValidValue(newValue, this);

 316                 return (R) temporal.with(MONTH_OF_YEAR, temporal.getLong(MONTH_OF_YEAR) + (newValue - curValue) * 3);
 317             }
 318             @Override
 319             public boolean resolve(DateTimeBuilder builder, long value) {
 320                 Long[] values = builder.queryFieldValues(YEAR, QUARTER_OF_YEAR, DAY_OF_QUARTER);
 321                 if (values[0] != null && values[1] != null && values[2] != null) {
 322                     int y = YEAR.range().checkValidIntValue(values[0], YEAR);
 323                     int qoy = QUARTER_OF_YEAR.range().checkValidIntValue(values[1], QUARTER_OF_YEAR);
 324                     int doq = DAY_OF_QUARTER.range().checkValidIntValue(values[2], DAY_OF_QUARTER);
 325                     LocalDate date = LocalDate.of(y, ((qoy - 1) * 3) + 1, 1).plusDays(doq - 1);
 326                     builder.addFieldValue(EPOCH_DAY, date.toEpochDay());
 327                     builder.removeFieldValues(QUARTER_OF_YEAR, DAY_OF_QUARTER);
 328                 }
 329                 return false;
 330             }
 331         },
 332         WEEK_OF_WEEK_BASED_YEAR {
 333             @Override
 334             public String getName() {
 335                 return "WeekOfWeekBasedYear";
 336             }
 337             @Override
 338             public TemporalUnit getBaseUnit() {
 339                 return WEEKS;
 340             }
 341             @Override
 342             public TemporalUnit getRangeUnit() {
 343                 return WEEK_BASED_YEARS;
 344             }
 345             @Override
 346             public ValueRange range() {
 347                 return ValueRange.of(1, 52, 53);
 348             }
 349             @Override
 350             public boolean doIsSupported(TemporalAccessor temporal) {
 351                 return temporal.isSupported(EPOCH_DAY);
 352             }
 353             @Override
 354             public ValueRange doRange(TemporalAccessor temporal) {



 355                 return getWeekRange(LocalDate.from(temporal));
 356             }
 357             @Override
 358             public long doGet(TemporalAccessor temporal) {



 359                 return getWeek(LocalDate.from(temporal));
 360             }

 361             @Override
 362             public <R extends Temporal> R doWith(R temporal, long newValue) {
 363                 ValueRange.of(1, 53).checkValidValue(newValue, this);
 364                 return (R) temporal.plus(Math.subtractExact(newValue, doGet(temporal)), WEEKS);
















 365             }
 366         },
 367         WEEK_BASED_YEAR {
 368             @Override
 369             public String getName() {
 370                 return "WeekBasedYear";
 371             }
 372             @Override
 373             public TemporalUnit getBaseUnit() {
 374                 return WEEK_BASED_YEARS;
 375             }
 376             @Override
 377             public TemporalUnit getRangeUnit() {
 378                 return FOREVER;
 379             }
 380             @Override
 381             public ValueRange range() {
 382                 return YEAR.range();
 383             }
 384             @Override
 385             public boolean doIsSupported(TemporalAccessor temporal) {
 386                 return temporal.isSupported(EPOCH_DAY);
 387             }
 388             @Override
 389             public long doGet(TemporalAccessor temporal) {



 390                 return getWeekBasedYear(LocalDate.from(temporal));
 391             }

 392             @Override
 393             public <R extends Temporal> R doWith(R temporal, long newValue) {
 394                 int newVal = range().checkValidIntValue(newValue, WEEK_BASED_YEAR);



 395                 LocalDate date = LocalDate.from(temporal);
 396                 int week = getWeek(date);
 397                 date = date.withDayOfYear(180).withYear(newVal).with(WEEK_OF_WEEK_BASED_YEAR, week);
 398                 return (R) date.with(date);
 399             }
 400             @Override
 401             public boolean resolve(DateTimeBuilder builder, long value) {
 402                 Long[] values = builder.queryFieldValues(WEEK_BASED_YEAR, WEEK_OF_WEEK_BASED_YEAR, DAY_OF_WEEK);
 403                 if (values[0] != null && values[1] != null && values[2] != null) {
 404                     int wby = WEEK_BASED_YEAR.range().checkValidIntValue(values[0], WEEK_BASED_YEAR);
 405                     int week = WEEK_OF_WEEK_BASED_YEAR.range().checkValidIntValue(values[1], WEEK_OF_WEEK_BASED_YEAR);
 406                     int dow = DAY_OF_WEEK.range().checkValidIntValue(values[2], DAY_OF_WEEK);
 407                     LocalDate date = LocalDate.of(wby, 2, 1).with(WEEK_OF_WEEK_BASED_YEAR, week).with(DAY_OF_WEEK, dow);
 408                     builder.addFieldValue(EPOCH_DAY, date.toEpochDay());
 409                     builder.removeFieldValues(WEEK_BASED_YEAR, WEEK_OF_WEEK_BASED_YEAR, DAY_OF_WEEK);
 410                 }
 411                 return false;
 412             }
 413         };
 414 
 415         @Override
 416         public ValueRange doRange(TemporalAccessor temporal) {
 417             return range();
 418         }
 419 
 420         @Override
 421         public boolean resolve(DateTimeBuilder builder, long value) {
 422             return false;
 423         }
 424 
 425         @Override
 426         public String toString() {
 427             return getName();
 428         }
 429 
 430         //-------------------------------------------------------------------------
 431         private static final int[] QUARTER_DAYS = {0, 90, 181, 273, 0, 91, 182, 274};
 432 




 433         private static ValueRange getWeekRange(LocalDate date) {
 434             int wby = getWeekBasedYear(date);
 435             date = date.withDayOfYear(1).withYear(wby);
 436             // 53 weeks if standard year starts on Thursday, or Wed in a leap year
 437             if (date.getDayOfWeek() == THURSDAY || (date.getDayOfWeek() == WEDNESDAY && date.isLeapYear())) {
 438                 return ValueRange.of(1, 53);
 439             }
 440             return ValueRange.of(1, 52);
 441         }
 442 
 443         private static int getWeek(LocalDate date) {
 444             int dow0 = date.getDayOfWeek().ordinal();
 445             int doy0 = date.getDayOfYear() - 1;
 446             int doyThu0 = doy0 + (3 - dow0);  // adjust to mid-week Thursday (which is 3 indexed from zero)
 447             int alignedWeek = doyThu0 / 7;
 448             int firstThuDoy0 = doyThu0 - (alignedWeek * 7);
 449             int firstMonDoy0 = firstThuDoy0 - 3;
 450             if (firstMonDoy0 < -3) {
 451                 firstMonDoy0 += 7;
 452             }


 503             this.name = name;
 504             this.duration = estimatedDuration;
 505         }
 506 
 507         @Override
 508         public String getName() {
 509             return name;
 510         }
 511 
 512         @Override
 513         public Duration getDuration() {
 514             return duration;
 515         }
 516 
 517         @Override
 518         public boolean isDurationEstimated() {
 519             return true;
 520         }
 521 
 522         @Override
 523         public boolean isSupported(Temporal temporal) {
 524             return temporal.isSupported(EPOCH_DAY);
 525         }
 526 

 527         @Override
 528         public <R extends Temporal> R doPlus(R dateTime, long periodToAdd) {
 529             switch(this) {
 530                 case WEEK_BASED_YEARS:
 531                     return (R) dateTime.with(WEEK_BASED_YEAR,
 532                             Math.addExact(dateTime.get(WEEK_BASED_YEAR), periodToAdd));
 533                 case QUARTER_YEARS:
 534                     // no overflow (256 is multiple of 4)
 535                     return (R) dateTime.plus(periodToAdd / 256, YEARS)
 536                             .plus((periodToAdd % 256) * 3, MONTHS);
 537                 default:
 538                     throw new IllegalStateException("Unreachable");
 539             }
 540         }
 541 
 542         @Override
 543         public <R extends Temporal> SimplePeriod between(R dateTime1, R dateTime2) {
 544             switch(this) {
 545                 case WEEK_BASED_YEARS:
 546                     long period = Math.subtractExact(dateTime2.getLong(WEEK_BASED_YEAR),
 547                             dateTime1.getLong(WEEK_BASED_YEAR));
 548                     return new SimplePeriod(period, WEEK_BASED_YEARS);
 549                 case QUARTER_YEARS:
 550                     long period2 = Math.subtractExact(dateTime2.getLong(QUARTER_OF_YEAR),
 551                             dateTime1.getLong(QUARTER_OF_YEAR));
 552                     return new SimplePeriod(period2, QUARTER_YEARS);
 553                 default:
 554                     throw new IllegalStateException("Unreachable");
 555             }
 556         }
 557 
 558         @Override
 559         public String toString() {
 560             return getName();
 561 
 562         }
 563     }
 564 }


  55  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  56  */
  57 package java.time.temporal;
  58 
  59 import static java.time.DayOfWeek.THURSDAY;
  60 import static java.time.DayOfWeek.WEDNESDAY;
  61 import static java.time.temporal.ChronoField.DAY_OF_WEEK;
  62 import static java.time.temporal.ChronoField.DAY_OF_YEAR;
  63 import static java.time.temporal.ChronoField.EPOCH_DAY;
  64 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
  65 import static java.time.temporal.ChronoField.YEAR;
  66 import static java.time.temporal.ChronoUnit.DAYS;
  67 import static java.time.temporal.ChronoUnit.FOREVER;
  68 import static java.time.temporal.ChronoUnit.MONTHS;
  69 import static java.time.temporal.ChronoUnit.WEEKS;
  70 import static java.time.temporal.ChronoUnit.YEARS;
  71 
  72 import java.time.DateTimeException;
  73 import java.time.Duration;
  74 import java.time.LocalDate;
  75 import java.time.chrono.Chronology;
  76 import java.time.chrono.IsoChronology;
  77 import java.util.HashMap;
  78 import java.util.Map;
  79 
  80 /**
  81  * Fields and units specific to the ISO-8601 calendar system,
  82  * including quarter-of-year and week-based-year.
  83  * <p>
  84  * This class defines fields and units that are specific to the ISO calendar system.
  85  *
  86  * <h3>Quarter of year</h3>
  87  * The ISO-8601 standard is based on the standard civic 12 month year.
  88  * This is commonly divided into four quarters, often abbreviated as Q1, Q2, Q3 and Q4.
  89  * <p>
  90  * January, February and March are in Q1.
  91  * April, May and June are in Q2.
  92  * July, August and September are in Q3.
  93  * October, November and December are in Q4.
  94  * <p>
  95  * The complete date is expressed using three fields:
  96  * <p><ul>
  97  * <li>{@link #DAY_OF_QUARTER DAY_OF_QUARTER} - the day within the quarter, from 1 to 90, 91 or 92
  98  * <li>{@link #QUARTER_OF_YEAR QUARTER_OF_YEAR} - the week within the week-based-year


 129  * <p>
 130  * For example:
 131  * <p>
 132  * <table cellpadding="0" cellspacing="3" border="0" style="text-align: left; width: 50%;">
 133  * <caption>Examples of Week based Years</caption>
 134  * <tr><th>Date</th><th>Day-of-week</th><th>Field values</th></tr>
 135  * <tr><th>2008-12-28</th><td>Sunday</td><td>Week 52 of week-based-year 2008</td></tr>
 136  * <tr><th>2008-12-29</th><td>Monday</td><td>Week 1 of week-based-year 2009</td></tr>
 137  * <tr><th>2008-12-31</th><td>Wednesday</td><td>Week 1 of week-based-year 2009</td></tr>
 138  * <tr><th>2009-01-01</th><td>Thursday</td><td>Week 1 of week-based-year 2009</td></tr>
 139  * <tr><th>2009-01-04</th><td>Sunday</td><td>Week 1 of week-based-year 2009</td></tr>
 140  * <tr><th>2009-01-05</th><td>Monday</td><td>Week 2 of week-based-year 2009</td></tr>
 141  * </table>
 142  *
 143  * <h3>Specification for implementors</h3>
 144  * <p>
 145  * This class is immutable and thread-safe.
 146  *
 147  * @since 1.8
 148  */
 149 public final class IsoFields {
 150 
 151     /**
 152      * The field that represents the day-of-quarter.
 153      * <p>
 154      * This field allows the day-of-quarter value to be queried and set.
 155      * The day-of-quarter has values from 1 to 90 in Q1 of a standard year, from 1 to 91
 156      * in Q1 of a leap year, from 1 to 91 in Q2 and from 1 to 92 in Q3 and Q4.
 157      * <p>
 158      * The day-of-quarter can only be calculated if the day-of-year, month-of-year and year
 159      * are available.
 160      * <p>
 161      * When setting this field, the value is allowed to be partially lenient, taking any
 162      * value from 1 to 92. If the quarter has less than 92 days, then day 92, and
 163      * potentially day 91, is in the following quarter.
 164      * <p>
 165      * This unit is an immutable and thread-safe singleton.
 166      */
 167     public static final TemporalField DAY_OF_QUARTER = Field.DAY_OF_QUARTER;
 168     /**
 169      * The field that represents the quarter-of-year.


 202      * <p>
 203      * The rules for addition add the number of week-based-years to the existing value
 204      * for the week-based-year field. If the resulting week-based-year only has 52 weeks,
 205      * then the date will be in week 1 of the following week-based-year.
 206      * <p>
 207      * This unit is an immutable and thread-safe singleton.
 208      */
 209     public static final TemporalUnit WEEK_BASED_YEARS = Unit.WEEK_BASED_YEARS;
 210     /**
 211      * Unit that represents the concept of a quarter-year.
 212      * For the ISO calendar system, it is equal to 3 months.
 213      * The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
 214      * <p>
 215      * This unit is an immutable and thread-safe singleton.
 216      */
 217     public static final TemporalUnit QUARTER_YEARS = Unit.QUARTER_YEARS;
 218 
 219     /**
 220      * Restricted constructor.
 221      */
 222     private IsoFields() {
 223         throw new AssertionError("Not instantiable");
 224     }
 225 
 226     //-----------------------------------------------------------------------
 227     /**
 228      * Implementation of the field.
 229      */
 230     private static enum Field implements TemporalField {
 231         DAY_OF_QUARTER {
 232             @Override
 233             public String getName() {
 234                 return "DayOfQuarter";
 235             }
 236             @Override
 237             public TemporalUnit getBaseUnit() {
 238                 return DAYS;
 239             }
 240             @Override
 241             public TemporalUnit getRangeUnit() {
 242                 return QUARTER_YEARS;
 243             }
 244             @Override
 245             public ValueRange range() {
 246                 return ValueRange.of(1, 90, 92);
 247             }
 248             @Override
 249             public boolean isSupportedBy(TemporalAccessor temporal) {
 250                 return temporal.isSupported(DAY_OF_YEAR) && temporal.isSupported(MONTH_OF_YEAR) &&
 251                         temporal.isSupported(YEAR) && isIso(temporal);
 252             }
 253             @Override
 254             public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
 255                 if (isSupportedBy(temporal) == false) {
 256                     throw new DateTimeException("Unsupported field: DayOfQuarter");
 257                 }
 258                 long qoy = temporal.getLong(QUARTER_OF_YEAR);
 259                 if (qoy == 1) {
 260                     long year = temporal.getLong(YEAR);
 261                     return (IsoChronology.INSTANCE.isLeapYear(year) ? ValueRange.of(1, 91) : ValueRange.of(1, 90));
 262                 } else if (qoy == 2) {
 263                     return ValueRange.of(1, 91);
 264                 } else if (qoy == 3 || qoy == 4) {
 265                     return ValueRange.of(1, 92);
 266                 } // else value not from 1 to 4, so drop through
 267                 return range();
 268             }
 269             @Override
 270             public long getFrom(TemporalAccessor temporal) {
 271                 if (isSupportedBy(temporal) == false) {
 272                     throw new DateTimeException("Unsupported field: DayOfQuarter");
 273                 }
 274                 int doy = temporal.get(DAY_OF_YEAR);
 275                 int moy = temporal.get(MONTH_OF_YEAR);
 276                 long year = temporal.getLong(YEAR);
 277                 return doy - QUARTER_DAYS[((moy - 1) / 3) + (IsoChronology.INSTANCE.isLeapYear(year) ? 4 : 0)];
 278             }
 279             @SuppressWarnings("unchecked")
 280             @Override
 281             public <R extends Temporal> R adjustInto(R temporal, long newValue) {
 282                 // calls getFrom() to check if supported
 283                 long curValue = getFrom(temporal);
 284                 range().checkValidValue(newValue, this);  // leniently check from 1 to 92 TODO: check
 285                 return (R) temporal.with(DAY_OF_YEAR, temporal.getLong(DAY_OF_YEAR) + (newValue - curValue));
 286             }
 287             @Override
 288             public Map<TemporalField, Long> resolve(TemporalAccessor temporal, long value) {
 289                 if ((temporal.isSupported(YEAR) && temporal.isSupported(DAY_OF_QUARTER)) == false) {
 290                     return null;
 291                 }
 292                 int y = temporal.get(YEAR);
 293                 int qoy = temporal.get(QUARTER_OF_YEAR);
 294                 range().checkValidValue(value, this);  // leniently check from 1 to 92 TODO: check
 295                 LocalDate date = LocalDate.of(y, ((qoy - 1) * 3) + 1, 1).plusDays(value - 1);
 296                 Map<TemporalField, Long> result = new HashMap<>(4, 1.0f);
 297                 result.put(EPOCH_DAY, date.toEpochDay());
 298                 result.put(YEAR, null);
 299                 result.put(QUARTER_OF_YEAR, null);
 300                 return result;
 301             }
 302         },
 303         QUARTER_OF_YEAR {
 304             @Override
 305             public String getName() {
 306                 return "QuarterOfYear";
 307             }
 308             @Override
 309             public TemporalUnit getBaseUnit() {
 310                 return QUARTER_YEARS;
 311             }
 312             @Override
 313             public TemporalUnit getRangeUnit() {
 314                 return YEARS;
 315             }
 316             @Override
 317             public ValueRange range() {
 318                 return ValueRange.of(1, 4);
 319             }
 320             @Override
 321             public boolean isSupportedBy(TemporalAccessor temporal) {
 322                 return temporal.isSupported(MONTH_OF_YEAR) && isIso(temporal);
 323             }
 324             @Override
 325             public long getFrom(TemporalAccessor temporal) {
 326                 if (isSupportedBy(temporal) == false) {
 327                     throw new DateTimeException("Unsupported field: QuarterOfYear");
 328                 }
 329                 long moy = temporal.getLong(MONTH_OF_YEAR);
 330                 return ((moy + 2) / 3);
 331             }
 332             @SuppressWarnings("unchecked")
 333             @Override
 334             public <R extends Temporal> R adjustInto(R temporal, long newValue) {
 335                 // calls getFrom() to check if supported
 336                 long curValue = getFrom(temporal);
 337                 range().checkValidValue(newValue, this);  // strictly check from 1 to 4
 338                 return (R) temporal.with(MONTH_OF_YEAR, temporal.getLong(MONTH_OF_YEAR) + (newValue - curValue) * 3);
 339             }













 340         },
 341         WEEK_OF_WEEK_BASED_YEAR {
 342             @Override
 343             public String getName() {
 344                 return "WeekOfWeekBasedYear";
 345             }
 346             @Override
 347             public TemporalUnit getBaseUnit() {
 348                 return WEEKS;
 349             }
 350             @Override
 351             public TemporalUnit getRangeUnit() {
 352                 return WEEK_BASED_YEARS;
 353             }
 354             @Override
 355             public ValueRange range() {
 356                 return ValueRange.of(1, 52, 53);
 357             }
 358             @Override
 359             public boolean isSupportedBy(TemporalAccessor temporal) {
 360                 return temporal.isSupported(EPOCH_DAY) && isIso(temporal);
 361             }
 362             @Override
 363             public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
 364                 if (isSupportedBy(temporal) == false) {
 365                     throw new DateTimeException("Unsupported field: WeekOfWeekBasedYear");
 366                 }
 367                 return getWeekRange(LocalDate.from(temporal));
 368             }
 369             @Override
 370             public long getFrom(TemporalAccessor temporal) {
 371                 if (isSupportedBy(temporal) == false) {
 372                     throw new DateTimeException("Unsupported field: WeekOfWeekBasedYear");
 373                 }
 374                 return getWeek(LocalDate.from(temporal));
 375             }
 376             @SuppressWarnings("unchecked")
 377             @Override
 378             public <R extends Temporal> R adjustInto(R temporal, long newValue) {
 379                 // calls getFrom() to check if supported
 380                 range().checkValidValue(newValue, this);  // lenient range
 381                 return (R) temporal.plus(Math.subtractExact(newValue, getFrom(temporal)), WEEKS);
 382             }
 383             @Override
 384             public Map<TemporalField, Long> resolve(TemporalAccessor temporal, long value) {
 385                 if ((temporal.isSupported(WEEK_BASED_YEAR) && temporal.isSupported(DAY_OF_WEEK)) == false) {
 386                     return null;
 387                 }
 388                 int wby = temporal.get(WEEK_BASED_YEAR);
 389                 int dow = temporal.get(DAY_OF_WEEK);
 390                 range().checkValidValue(value, this);  // lenient range
 391                 LocalDate date = LocalDate.of(wby, 1, 4).plusWeeks(value - 1).with(DAY_OF_WEEK, dow);
 392                 Map<TemporalField, Long> result = new HashMap<>(2, 1.0f);
 393                 result.put(EPOCH_DAY, date.toEpochDay());
 394                 result.put(WEEK_BASED_YEAR, null);
 395                 result.put(DAY_OF_WEEK, null);
 396                 return result;
 397             }
 398         },
 399         WEEK_BASED_YEAR {
 400             @Override
 401             public String getName() {
 402                 return "WeekBasedYear";
 403             }
 404             @Override
 405             public TemporalUnit getBaseUnit() {
 406                 return WEEK_BASED_YEARS;
 407             }
 408             @Override
 409             public TemporalUnit getRangeUnit() {
 410                 return FOREVER;
 411             }
 412             @Override
 413             public ValueRange range() {
 414                 return YEAR.range();
 415             }
 416             @Override
 417             public boolean isSupportedBy(TemporalAccessor temporal) {
 418                 return temporal.isSupported(EPOCH_DAY) && isIso(temporal);
 419             }
 420             @Override
 421             public long getFrom(TemporalAccessor temporal) {
 422                 if (isSupportedBy(temporal) == false) {
 423                     throw new DateTimeException("Unsupported field: WeekBasedYear");
 424                 }
 425                 return getWeekBasedYear(LocalDate.from(temporal));
 426             }
 427             @SuppressWarnings("unchecked")
 428             @Override
 429             public <R extends Temporal> R adjustInto(R temporal, long newValue) {
 430                 if (isSupportedBy(temporal) == false) {
 431                     throw new DateTimeException("Unsupported field: WeekBasedYear");
 432                 }
 433                 int newVal = range().checkValidIntValue(newValue, WEEK_BASED_YEAR);  // strict check
 434                 LocalDate date = LocalDate.from(temporal);
 435                 int week = getWeek(date);
 436                 date = date.withDayOfYear(180).withYear(newVal).with(WEEK_OF_WEEK_BASED_YEAR, week);
 437                 return (R) date.with(date);
 438             }













 439         };
 440 
 441         @Override
 442         public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
 443             return range();
 444         }
 445 
 446         @Override





 447         public String toString() {
 448             return getName();
 449         }
 450 
 451         //-------------------------------------------------------------------------
 452         private static final int[] QUARTER_DAYS = {0, 90, 181, 273, 0, 91, 182, 274};
 453 
 454         private static boolean isIso(TemporalAccessor temporal) {
 455             return Chronology.from(temporal).equals(IsoChronology.INSTANCE);
 456         }
 457 
 458         private static ValueRange getWeekRange(LocalDate date) {
 459             int wby = getWeekBasedYear(date);
 460             date = date.withDayOfYear(1).withYear(wby);
 461             // 53 weeks if standard year starts on Thursday, or Wed in a leap year
 462             if (date.getDayOfWeek() == THURSDAY || (date.getDayOfWeek() == WEDNESDAY && date.isLeapYear())) {
 463                 return ValueRange.of(1, 53);
 464             }
 465             return ValueRange.of(1, 52);
 466         }
 467 
 468         private static int getWeek(LocalDate date) {
 469             int dow0 = date.getDayOfWeek().ordinal();
 470             int doy0 = date.getDayOfYear() - 1;
 471             int doyThu0 = doy0 + (3 - dow0);  // adjust to mid-week Thursday (which is 3 indexed from zero)
 472             int alignedWeek = doyThu0 / 7;
 473             int firstThuDoy0 = doyThu0 - (alignedWeek * 7);
 474             int firstMonDoy0 = firstThuDoy0 - 3;
 475             if (firstMonDoy0 < -3) {
 476                 firstMonDoy0 += 7;
 477             }


 528             this.name = name;
 529             this.duration = estimatedDuration;
 530         }
 531 
 532         @Override
 533         public String getName() {
 534             return name;
 535         }
 536 
 537         @Override
 538         public Duration getDuration() {
 539             return duration;
 540         }
 541 
 542         @Override
 543         public boolean isDurationEstimated() {
 544             return true;
 545         }
 546 
 547         @Override
 548         public boolean isSupportedBy(Temporal temporal) {
 549             return temporal.isSupported(EPOCH_DAY);
 550         }
 551 
 552         @SuppressWarnings("unchecked")
 553         @Override
 554         public <R extends Temporal> R addTo(R temporal, long amount) {
 555             switch(this) {
 556                 case WEEK_BASED_YEARS:
 557                     return (R) temporal.with(WEEK_BASED_YEAR,
 558                             Math.addExact(temporal.get(WEEK_BASED_YEAR), amount));
 559                 case QUARTER_YEARS:
 560                     // no overflow (256 is multiple of 4)
 561                     return (R) temporal.plus(amount / 256, YEARS)
 562                             .plus((amount % 256) * 3, MONTHS);
 563                 default:
 564                     throw new IllegalStateException("Unreachable");
 565             }
 566         }
 567 
 568         @Override
 569         public long between(Temporal temporal1, Temporal temporal2) {
 570             switch(this) {
 571                 case WEEK_BASED_YEARS:
 572                     return Math.subtractExact(temporal2.getLong(WEEK_BASED_YEAR),
 573                             temporal1.getLong(WEEK_BASED_YEAR));

 574                 case QUARTER_YEARS:
 575                     return temporal1.periodUntil(temporal2, MONTHS) / 3;


 576                 default:
 577                     throw new IllegalStateException("Unreachable");
 578             }
 579         }
 580 
 581         @Override
 582         public String toString() {
 583             return getName();
 584 
 585         }
 586     }
 587 }