1 /*
2 * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * This file is available under and governed by the GNU General Public
28 * License version 2 only, as published by the Free Software Foundation.
29 * However, the following notice accompanied the original version of this
30 * file:
31 *
32 * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
33 *
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions are met:
38 *
39 * * Redistributions of source code must retain the above copyright notice,
40 * this list of conditions and the following disclaimer.
41 *
42 * * Redistributions in binary form must reproduce the above copyright notice,
43 * this list of conditions and the following disclaimer in the documentation
44 * and/or other materials provided with the distribution.
45 *
46 * * Neither the name of JSR-310 nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
54 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
55 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
56 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
57 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
58 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
59 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
60 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 */
62 package java.time.temporal;
63
64 import static java.time.temporal.ChronoField.DAY_OF_MONTH;
65 import static java.time.temporal.ChronoField.DAY_OF_WEEK;
66 import static java.time.temporal.ChronoField.DAY_OF_YEAR;
67 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
68 import static java.time.temporal.ChronoField.YEAR;
69 import static java.time.temporal.ChronoUnit.DAYS;
70 import static java.time.temporal.ChronoUnit.FOREVER;
71 import static java.time.temporal.ChronoUnit.MONTHS;
72 import static java.time.temporal.ChronoUnit.WEEKS;
73 import static java.time.temporal.ChronoUnit.YEARS;
74
75 import java.io.IOException;
76 import java.io.InvalidObjectException;
77 import java.io.ObjectInputStream;
78 import java.io.Serializable;
79 import java.time.DateTimeException;
80 import java.time.DayOfWeek;
81 import java.time.chrono.ChronoLocalDate;
82 import java.time.chrono.Chronology;
83 import java.time.format.ResolverStyle;
84 import java.util.Locale;
85 import java.util.Map;
86 import java.util.Objects;
87 import java.util.ResourceBundle;
88 import java.util.concurrent.ConcurrentHashMap;
89 import java.util.concurrent.ConcurrentMap;
90 import sun.util.locale.provider.CalendarDataUtility;
91 import sun.util.locale.provider.LocaleProviderAdapter;
92 import sun.util.locale.provider.LocaleResources;
93
94 /**
95 * Localized definitions of the day-of-week, week-of-month and week-of-year fields.
96 * <p>
97 * A standard week is seven days long, but cultures have different definitions for some
98 * other aspects of a week. This class represents the definition of the week, for the
99 * purpose of providing {@link TemporalField} instances.
100 * <p>
101 * WeekFields provides five fields,
102 * {@link #dayOfWeek()}, {@link #weekOfMonth()}, {@link #weekOfYear()},
103 * {@link #weekOfWeekBasedYear()}, and {@link #weekBasedYear()}
104 * that provide access to the values from any {@linkplain Temporal temporal object}.
105 * <p>
106 * The computations for day-of-week, week-of-month, and week-of-year are based
107 * on the {@linkplain ChronoField#YEAR proleptic-year},
108 * {@linkplain ChronoField#MONTH_OF_YEAR month-of-year},
109 * {@linkplain ChronoField#DAY_OF_MONTH day-of-month}, and
110 * {@linkplain ChronoField#DAY_OF_WEEK ISO day-of-week} which are based on the
111 * {@linkplain ChronoField#EPOCH_DAY epoch-day} and the chronology.
112 * The values may not be aligned with the {@linkplain ChronoField#YEAR_OF_ERA year-of-Era}
113 * depending on the Chronology.
114 * <p>A week is defined by:
115 * <ul>
116 * <li>The first day-of-week.
117 * For example, the ISO-8601 standard considers Monday to be the first day-of-week.
118 * <li>The minimal number of days in the first week.
119 * For example, the ISO-8601 standard counts the first week as needing at least 4 days.
120 * </ul>
121 * Together these two values allow a year or month to be divided into weeks.
122 *
123 * <h3>Week of Month</h3>
124 * One field is used: week-of-month.
125 * The calculation ensures that weeks never overlap a month boundary.
126 * The month is divided into periods where each period starts on the defined first day-of-week.
127 * The earliest period is referred to as week 0 if it has less than the minimal number of days
128 * and week 1 if it has at least the minimal number of days.
129 *
130 * <table class=striped style="text-align: left">
131 * <caption>Examples of WeekFields</caption>
132 * <thead>
133 * <tr><th scope="col">Date</th><th scope="col">Day-of-week</th>
134 * <th scope="col">First day: Monday<br>Minimal days: 4</th><th scope="col">First day: Monday<br>Minimal days: 5</th></tr>
135 * </thead>
136 * <tbody>
137 * <tr><th scope="row">2008-12-31</th><td>Wednesday</td>
138 * <td>Week 5 of December 2008</td><td>Week 5 of December 2008</td></tr>
139 * <tr><th scope="row">2009-01-01</th><td>Thursday</td>
140 * <td>Week 1 of January 2009</td><td>Week 0 of January 2009</td></tr>
141 * <tr><th scope="row">2009-01-04</th><td>Sunday</td>
142 * <td>Week 1 of January 2009</td><td>Week 0 of January 2009</td></tr>
143 * <tr><th scope="row">2009-01-05</th><td>Monday</td>
144 * <td>Week 2 of January 2009</td><td>Week 1 of January 2009</td></tr>
145 * </tbody>
146 * </table>
147 *
148 * <h3>Week of Year</h3>
149 * One field is used: week-of-year.
150 * The calculation ensures that weeks never overlap a year boundary.
151 * The year is divided into periods where each period starts on the defined first day-of-week.
152 * The earliest period is referred to as week 0 if it has less than the minimal number of days
153 * and week 1 if it has at least the minimal number of days.
154 *
155 * <h3>Week Based Year</h3>
156 * Two fields are used for week-based-year, one for the
157 * {@link #weekOfWeekBasedYear() week-of-week-based-year} and one for
158 * {@link #weekBasedYear() week-based-year}. In a week-based-year, each week
159 * belongs to only a single year. Week 1 of a year is the first week that
160 * starts on the first day-of-week and has at least the minimum number of days.
161 * The first and last weeks of a year may contain days from the
162 * previous calendar year or next calendar year respectively.
163 *
164 * <table class=striped style="text-align: left;">
165 * <caption>Examples of WeekFields for week-based-year</caption>
166 * <thead>
167 * <tr><th scope="col">Date</th><th scope="col">Day-of-week</th>
168 * <th scope="col">First day: Monday<br>Minimal days: 4</th><th scope="col">First day: Monday<br>Minimal days: 5</th></tr>
169 * </thead>
170 * <tbody>
171 * <tr><th scope="row">2008-12-31</th><td>Wednesday</td>
172 * <td>Week 1 of 2009</td><td>Week 53 of 2008</td></tr>
173 * <tr><th scope="row">2009-01-01</th><td>Thursday</td>
174 * <td>Week 1 of 2009</td><td>Week 53 of 2008</td></tr>
175 * <tr><th scope="row">2009-01-04</th><td>Sunday</td>
176 * <td>Week 1 of 2009</td><td>Week 53 of 2008</td></tr>
177 * <tr><th scope="row">2009-01-05</th><td>Monday</td>
178 * <td>Week 2 of 2009</td><td>Week 1 of 2009</td></tr>
179 * </tbody>
180 * </table>
181 *
182 * @implSpec
183 * This class is immutable and thread-safe.
184 *
185 * @since 1.8
186 */
187 public final class WeekFields implements Serializable {
188 // implementation notes
189 // querying week-of-month or week-of-year should return the week value bound within the month/year
190 // however, setting the week value should be lenient (use plus/minus weeks)
191 // allow week-of-month outer range [0 to 6]
192 // allow week-of-year outer range [0 to 54]
193 // this is because callers shouldn't be expected to know the details of validity
194
195 /**
196 * The cache of rules by firstDayOfWeek plus minimalDays.
197 * Initialized first to be available for definition of ISO, etc.
198 */
199 private static final ConcurrentMap<String, WeekFields> CACHE = new ConcurrentHashMap<>(4, 0.75f, 2);
200
201 /**
202 * The ISO-8601 definition, where a week starts on Monday and the first week
203 * has a minimum of 4 days.
204 * <p>
205 * The ISO-8601 standard defines a calendar system based on weeks.
206 * It uses the week-based-year and week-of-week-based-year concepts to split
207 * up the passage of days instead of the standard year/month/day.
208 * <p>
209 * Note that the first week may start in the previous calendar year.
210 * Note also that the first few days of a calendar year may be in the
211 * week-based-year corresponding to the previous calendar year.
212 */
213 public static final WeekFields ISO = new WeekFields(DayOfWeek.MONDAY, 4);
214
215 /**
216 * The common definition of a week that starts on Sunday and the first week
217 * has a minimum of 1 day.
218 * <p>
219 * Defined as starting on Sunday and with a minimum of 1 day in the month.
220 * This week definition is in use in the US and other European countries.
221 */
222 public static final WeekFields SUNDAY_START = WeekFields.of(DayOfWeek.SUNDAY, 1);
223
224 /**
225 * The unit that represents week-based-years for the purpose of addition and subtraction.
226 * <p>
227 * This allows a number of week-based-years to be added to, or subtracted from, a date.
228 * The unit is equal to either 52 or 53 weeks.
229 * The estimated duration of a week-based-year is the same as that of a standard ISO
230 * year at {@code 365.2425 Days}.
231 * <p>
232 * The rules for addition add the number of week-based-years to the existing value
233 * for the week-based-year field retaining the week-of-week-based-year
234 * and day-of-week, unless the week number it too large for the target year.
235 * In that case, the week is set to the last week of the year
236 * with the same day-of-week.
237 * <p>
238 * This unit is an immutable and thread-safe singleton.
239 */
240 public static final TemporalUnit WEEK_BASED_YEARS = IsoFields.WEEK_BASED_YEARS;
241
242 /**
243 * Serialization version.
244 */
245 private static final long serialVersionUID = -1177360819670808121L;
246
247 /**
248 * The first day-of-week.
249 */
250 private final DayOfWeek firstDayOfWeek;
251 /**
252 * The minimal number of days in the first week.
253 */
254 private final int minimalDays;
255 /**
256 * The field used to access the computed DayOfWeek.
257 */
258 private final transient TemporalField dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
259 /**
260 * The field used to access the computed WeekOfMonth.
261 */
262 private final transient TemporalField weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
263 /**
264 * The field used to access the computed WeekOfYear.
265 */
266 private final transient TemporalField weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
267 /**
268 * The field that represents the week-of-week-based-year.
269 * <p>
270 * This field allows the week of the week-based-year value to be queried and set.
271 * <p>
272 * This unit is an immutable and thread-safe singleton.
273 */
274 private final transient TemporalField weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
275 /**
276 * The field that represents the week-based-year.
277 * <p>
278 * This field allows the week-based-year value to be queried and set.
279 * <p>
280 * This unit is an immutable and thread-safe singleton.
281 */
282 private final transient TemporalField weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
283
284 //-----------------------------------------------------------------------
285 /**
286 * Obtains an instance of {@code WeekFields} appropriate for a locale.
287 * <p>
288 * This will look up appropriate values from the provider of localization data.
289 * If the locale contains "fw" (First day of week) and/or "rg"
290 * (Region Override) <a href="../../util/Locale.html#def_locale_extension">
291 * Unicode extensions</a>, returned instance will reflect the values specified with
292 * those extensions. If both "fw" and "rg" are specified, the value from
293 * the "fw" extension supersedes the implicit one from the "rg" extension.
294 *
295 * @param locale the locale to use, not null
296 * @return the week-definition, not null
297 */
298 public static WeekFields of(Locale locale) {
299 Objects.requireNonNull(locale, "locale");
300
301 int calDow = CalendarDataUtility.retrieveFirstDayOfWeek(locale);
302 DayOfWeek dow = DayOfWeek.SUNDAY.plus(calDow - 1);
303 int minDays = CalendarDataUtility.retrieveMinimalDaysInFirstWeek(locale);
304 return WeekFields.of(dow, minDays);
305 }
306
307 /**
308 * Obtains an instance of {@code WeekFields} from the first day-of-week and minimal days.
309 * <p>
310 * The first day-of-week defines the ISO {@code DayOfWeek} that is day 1 of the week.
311 * The minimal number of days in the first week defines how many days must be present
312 * in a month or year, starting from the first day-of-week, before the week is counted
313 * as the first week. A value of 1 will count the first day of the month or year as part
314 * of the first week, whereas a value of 7 will require the whole seven days to be in
315 * the new month or year.
316 * <p>
317 * WeekFields instances are singletons; for each unique combination
318 * of {@code firstDayOfWeek} and {@code minimalDaysInFirstWeek}
319 * the same instance will be returned.
320 *
321 * @param firstDayOfWeek the first day of the week, not null
322 * @param minimalDaysInFirstWeek the minimal number of days in the first week, from 1 to 7
323 * @return the week-definition, not null
324 * @throws IllegalArgumentException if the minimal days value is less than one
325 * or greater than 7
326 */
327 public static WeekFields of(DayOfWeek firstDayOfWeek, int minimalDaysInFirstWeek) {
328 String key = firstDayOfWeek.toString() + minimalDaysInFirstWeek;
329 WeekFields rules = CACHE.get(key);
330 if (rules == null) {
331 rules = new WeekFields(firstDayOfWeek, minimalDaysInFirstWeek);
332 CACHE.putIfAbsent(key, rules);
333 rules = CACHE.get(key);
334 }
335 return rules;
336 }
337
338 //-----------------------------------------------------------------------
339 /**
340 * Creates an instance of the definition.
341 *
342 * @param firstDayOfWeek the first day of the week, not null
343 * @param minimalDaysInFirstWeek the minimal number of days in the first week, from 1 to 7
344 * @throws IllegalArgumentException if the minimal days value is invalid
345 */
346 private WeekFields(DayOfWeek firstDayOfWeek, int minimalDaysInFirstWeek) {
347 Objects.requireNonNull(firstDayOfWeek, "firstDayOfWeek");
348 if (minimalDaysInFirstWeek < 1 || minimalDaysInFirstWeek > 7) {
349 throw new IllegalArgumentException("Minimal number of days is invalid");
350 }
351 this.firstDayOfWeek = firstDayOfWeek;
352 this.minimalDays = minimalDaysInFirstWeek;
353 }
354
355 //-----------------------------------------------------------------------
356 /**
357 * Restore the state of a WeekFields from the stream.
358 * Check that the values are valid.
359 *
360 * @param s the stream to read
361 * @throws InvalidObjectException if the serialized object has an invalid
362 * value for firstDayOfWeek or minimalDays.
363 * @throws ClassNotFoundException if a class cannot be resolved
364 */
365 private void readObject(ObjectInputStream s)
366 throws IOException, ClassNotFoundException, InvalidObjectException
367 {
368 s.defaultReadObject();
369 if (firstDayOfWeek == null) {
370 throw new InvalidObjectException("firstDayOfWeek is null");
371 }
372
373 if (minimalDays < 1 || minimalDays > 7) {
374 throw new InvalidObjectException("Minimal number of days is invalid");
375 }
376 }
377
378 /**
379 * Return the singleton WeekFields associated with the
380 * {@code firstDayOfWeek} and {@code minimalDays}.
381 * @return the singleton WeekFields for the firstDayOfWeek and minimalDays.
382 * @throws InvalidObjectException if the serialized object has invalid
383 * values for firstDayOfWeek or minimalDays.
384 */
385 private Object readResolve() throws InvalidObjectException {
386 try {
387 return WeekFields.of(firstDayOfWeek, minimalDays);
388 } catch (IllegalArgumentException iae) {
389 throw new InvalidObjectException("Invalid serialized WeekFields: " + iae.getMessage());
390 }
391 }
392
393 //-----------------------------------------------------------------------
394 /**
395 * Gets the first day-of-week.
396 * <p>
397 * The first day-of-week varies by culture.
398 * For example, the US uses Sunday, while France and the ISO-8601 standard use Monday.
399 * This method returns the first day using the standard {@code DayOfWeek} enum.
400 *
401 * @return the first day-of-week, not null
402 */
403 public DayOfWeek getFirstDayOfWeek() {
404 return firstDayOfWeek;
405 }
406
407 /**
408 * Gets the minimal number of days in the first week.
409 * <p>
410 * The number of days considered to define the first week of a month or year
411 * varies by culture.
412 * For example, the ISO-8601 requires 4 days (more than half a week) to
413 * be present before counting the first week.
414 *
415 * @return the minimal number of days in the first week of a month or year, from 1 to 7
416 */
417 public int getMinimalDaysInFirstWeek() {
418 return minimalDays;
419 }
420
421 //-----------------------------------------------------------------------
422 /**
423 * Returns a field to access the day of week based on this {@code WeekFields}.
424 * <p>
425 * This is similar to {@link ChronoField#DAY_OF_WEEK} but uses values for
426 * the day-of-week based on this {@code WeekFields}.
427 * The days are numbered from 1 to 7 where the
428 * {@link #getFirstDayOfWeek() first day-of-week} is assigned the value 1.
429 * <p>
430 * For example, if the first day-of-week is Sunday, then that will have the
431 * value 1, with other days ranging from Monday as 2 to Saturday as 7.
432 * <p>
433 * In the resolving phase of parsing, a localized day-of-week will be converted
434 * to a standardized {@code ChronoField} day-of-week.
435 * The day-of-week must be in the valid range 1 to 7.
436 * Other fields in this class build dates using the standardized day-of-week.
437 *
438 * @return a field providing access to the day-of-week with localized numbering, not null
439 */
440 public TemporalField dayOfWeek() {
441 return dayOfWeek;
442 }
443
444 /**
445 * Returns a field to access the week of month based on this {@code WeekFields}.
446 * <p>
447 * This represents the concept of the count of weeks within the month where weeks
448 * start on a fixed day-of-week, such as Monday.
449 * This field is typically used with {@link WeekFields#dayOfWeek()}.
450 * <p>
451 * Week one (1) is the week starting on the {@link WeekFields#getFirstDayOfWeek}
452 * where there are at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the month.
453 * Thus, week one may start up to {@code minDays} days before the start of the month.
454 * If the first week starts after the start of the month then the period before is week zero (0).
455 * <p>
456 * For example:<br>
457 * - if the 1st day of the month is a Monday, week one starts on the 1st and there is no week zero<br>
458 * - if the 2nd day of the month is a Monday, week one starts on the 2nd and the 1st is in week zero<br>
459 * - if the 4th day of the month is a Monday, week one starts on the 4th and the 1st to 3rd is in week zero<br>
460 * - if the 5th day of the month is a Monday, week two starts on the 5th and the 1st to 4th is in week one<br>
461 * <p>
462 * This field can be used with any calendar system.
463 * <p>
464 * In the resolving phase of parsing, a date can be created from a year,
465 * week-of-month, month-of-year and day-of-week.
466 * <p>
467 * In {@linkplain ResolverStyle#STRICT strict mode}, all four fields are
468 * validated against their range of valid values. The week-of-month field
469 * is validated to ensure that the resulting month is the month requested.
470 * <p>
471 * In {@linkplain ResolverStyle#SMART smart mode}, all four fields are
472 * validated against their range of valid values. The week-of-month field
473 * is validated from 0 to 6, meaning that the resulting date can be in a
474 * different month to that specified.
475 * <p>
476 * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week
477 * are validated against the range of valid values. The resulting date is calculated
478 * equivalent to the following four stage approach.
479 * First, create a date on the first day of the first week of January in the requested year.
480 * Then take the month-of-year, subtract one, and add the amount in months to the date.
481 * Then take the week-of-month, subtract one, and add the amount in weeks to the date.
482 * Finally, adjust to the correct day-of-week within the localized week.
483 *
484 * @return a field providing access to the week-of-month, not null
485 */
486 public TemporalField weekOfMonth() {
487 return weekOfMonth;
488 }
489
490 /**
491 * Returns a field to access the week of year based on this {@code WeekFields}.
492 * <p>
493 * This represents the concept of the count of weeks within the year where weeks
494 * start on a fixed day-of-week, such as Monday.
495 * This field is typically used with {@link WeekFields#dayOfWeek()}.
496 * <p>
497 * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek}
498 * where there are at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year.
499 * Thus, week one may start up to {@code minDays} days before the start of the year.
500 * If the first week starts after the start of the year then the period before is week zero (0).
501 * <p>
502 * For example:<br>
503 * - if the 1st day of the year is a Monday, week one starts on the 1st and there is no week zero<br>
504 * - if the 2nd day of the year is a Monday, week one starts on the 2nd and the 1st is in week zero<br>
505 * - if the 4th day of the year is a Monday, week one starts on the 4th and the 1st to 3rd is in week zero<br>
506 * - if the 5th day of the year is a Monday, week two starts on the 5th and the 1st to 4th is in week one<br>
507 * <p>
508 * This field can be used with any calendar system.
509 * <p>
510 * In the resolving phase of parsing, a date can be created from a year,
511 * week-of-year and day-of-week.
512 * <p>
513 * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are
514 * validated against their range of valid values. The week-of-year field
515 * is validated to ensure that the resulting year is the year requested.
516 * <p>
517 * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are
518 * validated against their range of valid values. The week-of-year field
519 * is validated from 0 to 54, meaning that the resulting date can be in a
520 * different year to that specified.
521 * <p>
522 * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week
523 * are validated against the range of valid values. The resulting date is calculated
524 * equivalent to the following three stage approach.
525 * First, create a date on the first day of the first week in the requested year.
526 * Then take the week-of-year, subtract one, and add the amount in weeks to the date.
527 * Finally, adjust to the correct day-of-week within the localized week.
528 *
529 * @return a field providing access to the week-of-year, not null
530 */
531 public TemporalField weekOfYear() {
532 return weekOfYear;
533 }
534
535 /**
536 * Returns a field to access the week of a week-based-year based on this {@code WeekFields}.
537 * <p>
538 * This represents the concept of the count of weeks within the year where weeks
539 * start on a fixed day-of-week, such as Monday and each week belongs to exactly one year.
540 * This field is typically used with {@link WeekFields#dayOfWeek()} and
541 * {@link WeekFields#weekBasedYear()}.
542 * <p>
543 * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek}
544 * where there are at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year.
545 * If the first week starts after the start of the year then the period before
546 * is in the last week of the previous year.
547 * <p>
548 * For example:<br>
549 * - if the 1st day of the year is a Monday, week one starts on the 1st<br>
550 * - if the 2nd day of the year is a Monday, week one starts on the 2nd and
551 * the 1st is in the last week of the previous year<br>
552 * - if the 4th day of the year is a Monday, week one starts on the 4th and
553 * the 1st to 3rd is in the last week of the previous year<br>
554 * - if the 5th day of the year is a Monday, week two starts on the 5th and
555 * the 1st to 4th is in week one<br>
556 * <p>
557 * This field can be used with any calendar system.
558 * <p>
559 * In the resolving phase of parsing, a date can be created from a week-based-year,
560 * week-of-year and day-of-week.
561 * <p>
562 * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are
563 * validated against their range of valid values. The week-of-year field
564 * is validated to ensure that the resulting week-based-year is the
565 * week-based-year requested.
566 * <p>
567 * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are
568 * validated against their range of valid values. The week-of-week-based-year field
569 * is validated from 1 to 53, meaning that the resulting date can be in the
570 * following week-based-year to that specified.
571 * <p>
572 * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week
573 * are validated against the range of valid values. The resulting date is calculated
574 * equivalent to the following three stage approach.
575 * First, create a date on the first day of the first week in the requested week-based-year.
576 * Then take the week-of-week-based-year, subtract one, and add the amount in weeks to the date.
577 * Finally, adjust to the correct day-of-week within the localized week.
578 *
579 * @return a field providing access to the week-of-week-based-year, not null
580 */
581 public TemporalField weekOfWeekBasedYear() {
582 return weekOfWeekBasedYear;
583 }
584
585 /**
586 * Returns a field to access the year of a week-based-year based on this {@code WeekFields}.
587 * <p>
588 * This represents the concept of the year where weeks start on a fixed day-of-week,
589 * such as Monday and each week belongs to exactly one year.
590 * This field is typically used with {@link WeekFields#dayOfWeek()} and
591 * {@link WeekFields#weekOfWeekBasedYear()}.
592 * <p>
593 * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek}
594 * where there are at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year.
595 * Thus, week one may start before the start of the year.
596 * If the first week starts after the start of the year then the period before
597 * is in the last week of the previous year.
598 * <p>
599 * This field can be used with any calendar system.
600 * <p>
601 * In the resolving phase of parsing, a date can be created from a week-based-year,
602 * week-of-year and day-of-week.
603 * <p>
604 * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are
605 * validated against their range of valid values. The week-of-year field
606 * is validated to ensure that the resulting week-based-year is the
607 * week-based-year requested.
608 * <p>
609 * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are
610 * validated against their range of valid values. The week-of-week-based-year field
611 * is validated from 1 to 53, meaning that the resulting date can be in the
612 * following week-based-year to that specified.
613 * <p>
614 * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week
615 * are validated against the range of valid values. The resulting date is calculated
616 * equivalent to the following three stage approach.
617 * First, create a date on the first day of the first week in the requested week-based-year.
618 * Then take the week-of-week-based-year, subtract one, and add the amount in weeks to the date.
619 * Finally, adjust to the correct day-of-week within the localized week.
620 *
621 * @return a field providing access to the week-based-year, not null
622 */
623 public TemporalField weekBasedYear() {
624 return weekBasedYear;
625 }
626
627 //-----------------------------------------------------------------------
628 /**
629 * Checks if this {@code WeekFields} is equal to the specified object.
630 * <p>
631 * The comparison is based on the entire state of the rules, which is
632 * the first day-of-week and minimal days.
633 *
634 * @param object the other rules to compare to, null returns false
635 * @return true if this is equal to the specified rules
636 */
637 @Override
638 public boolean equals(Object object) {
639 if (this == object) {
640 return true;
641 }
642 if (object instanceof WeekFields) {
643 return hashCode() == object.hashCode();
644 }
645 return false;
646 }
647
648 /**
649 * A hash code for this {@code WeekFields}.
650 *
651 * @return a suitable hash code
652 */
653 @Override
654 public int hashCode() {
655 return firstDayOfWeek.ordinal() * 7 + minimalDays;
656 }
657
658 //-----------------------------------------------------------------------
659 /**
660 * A string representation of this {@code WeekFields} instance.
661 *
662 * @return the string representation, not null
663 */
664 @Override
665 public String toString() {
666 return "WeekFields[" + firstDayOfWeek + ',' + minimalDays + ']';
667 }
668
669 //-----------------------------------------------------------------------
670 /**
671 * Field type that computes DayOfWeek, WeekOfMonth, and WeekOfYear
672 * based on a WeekFields.
673 * A separate Field instance is required for each different WeekFields;
674 * combination of start of week and minimum number of days.
675 * Constructors are provided to create fields for DayOfWeek, WeekOfMonth,
676 * and WeekOfYear.
677 */
678 static class ComputedDayOfField implements TemporalField {
679
680 /**
681 * Returns a field to access the day of week,
682 * computed based on a WeekFields.
683 * <p>
684 * The WeekDefintion of the first day of the week is used with
685 * the ISO DAY_OF_WEEK field to compute week boundaries.
686 */
687 static ComputedDayOfField ofDayOfWeekField(WeekFields weekDef) {
688 return new ComputedDayOfField("DayOfWeek", weekDef, DAYS, WEEKS, DAY_OF_WEEK_RANGE);
689 }
690
691 /**
692 * Returns a field to access the week of month,
693 * computed based on a WeekFields.
694 * @see WeekFields#weekOfMonth()
695 */
696 static ComputedDayOfField ofWeekOfMonthField(WeekFields weekDef) {
697 return new ComputedDayOfField("WeekOfMonth", weekDef, WEEKS, MONTHS, WEEK_OF_MONTH_RANGE);
698 }
699
700 /**
701 * Returns a field to access the week of year,
702 * computed based on a WeekFields.
703 * @see WeekFields#weekOfYear()
704 */
705 static ComputedDayOfField ofWeekOfYearField(WeekFields weekDef) {
706 return new ComputedDayOfField("WeekOfYear", weekDef, WEEKS, YEARS, WEEK_OF_YEAR_RANGE);
707 }
708
709 /**
710 * Returns a field to access the week of week-based-year,
711 * computed based on a WeekFields.
712 * @see WeekFields#weekOfWeekBasedYear()
713 */
714 static ComputedDayOfField ofWeekOfWeekBasedYearField(WeekFields weekDef) {
715 return new ComputedDayOfField("WeekOfWeekBasedYear", weekDef, WEEKS, IsoFields.WEEK_BASED_YEARS, WEEK_OF_WEEK_BASED_YEAR_RANGE);
716 }
717
718 /**
719 * Returns a field to access the week of week-based-year,
720 * computed based on a WeekFields.
721 * @see WeekFields#weekBasedYear()
722 */
723 static ComputedDayOfField ofWeekBasedYearField(WeekFields weekDef) {
724 return new ComputedDayOfField("WeekBasedYear", weekDef, IsoFields.WEEK_BASED_YEARS, FOREVER, ChronoField.YEAR.range());
725 }
726
727 /**
728 * Return a new week-based-year date of the Chronology, year, week-of-year,
729 * and dow of week.
730 * @param chrono The chronology of the new date
731 * @param yowby the year of the week-based-year
732 * @param wowby the week of the week-based-year
733 * @param dow the day of the week
734 * @return a ChronoLocalDate for the requested year, week of year, and day of week
735 */
736 private ChronoLocalDate ofWeekBasedYear(Chronology chrono,
737 int yowby, int wowby, int dow) {
738 ChronoLocalDate date = chrono.date(yowby, 1, 1);
739 int ldow = localizedDayOfWeek(date);
740 int offset = startOfWeekOffset(1, ldow);
741
742 // Clamp the week of year to keep it in the same year
743 int yearLen = date.lengthOfYear();
744 int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());
745 wowby = Math.min(wowby, newYearWeek - 1);
746
747 int days = -offset + (dow - 1) + (wowby - 1) * 7;
748 return date.plus(days, DAYS);
749 }
750
751 private final String name;
752 private final WeekFields weekDef;
753 private final TemporalUnit baseUnit;
754 private final TemporalUnit rangeUnit;
755 private final ValueRange range;
756
757 private ComputedDayOfField(String name, WeekFields weekDef, TemporalUnit baseUnit, TemporalUnit rangeUnit, ValueRange range) {
758 this.name = name;
759 this.weekDef = weekDef;
760 this.baseUnit = baseUnit;
761 this.rangeUnit = rangeUnit;
762 this.range = range;
763 }
764
765 private static final ValueRange DAY_OF_WEEK_RANGE = ValueRange.of(1, 7);
766 private static final ValueRange WEEK_OF_MONTH_RANGE = ValueRange.of(0, 1, 4, 6);
767 private static final ValueRange WEEK_OF_YEAR_RANGE = ValueRange.of(0, 1, 52, 54);
768 private static final ValueRange WEEK_OF_WEEK_BASED_YEAR_RANGE = ValueRange.of(1, 52, 53);
769
770 @Override
771 public long getFrom(TemporalAccessor temporal) {
772 if (rangeUnit == WEEKS) { // day-of-week
773 return localizedDayOfWeek(temporal);
774 } else if (rangeUnit == MONTHS) { // week-of-month
775 return localizedWeekOfMonth(temporal);
776 } else if (rangeUnit == YEARS) { // week-of-year
777 return localizedWeekOfYear(temporal);
778 } else if (rangeUnit == WEEK_BASED_YEARS) {
779 return localizedWeekOfWeekBasedYear(temporal);
780 } else if (rangeUnit == FOREVER) {
781 return localizedWeekBasedYear(temporal);
782 } else {
783 throw new IllegalStateException("unreachable, rangeUnit: " + rangeUnit + ", this: " + this);
784 }
785 }
786
787 private int localizedDayOfWeek(TemporalAccessor temporal) {
788 int sow = weekDef.getFirstDayOfWeek().getValue();
789 int isoDow = temporal.get(DAY_OF_WEEK);
790 return Math.floorMod(isoDow - sow, 7) + 1;
791 }
792
793 private int localizedDayOfWeek(int isoDow) {
794 int sow = weekDef.getFirstDayOfWeek().getValue();
795 return Math.floorMod(isoDow - sow, 7) + 1;
796 }
797
798 private long localizedWeekOfMonth(TemporalAccessor temporal) {
799 int dow = localizedDayOfWeek(temporal);
800 int dom = temporal.get(DAY_OF_MONTH);
801 int offset = startOfWeekOffset(dom, dow);
802 return computeWeek(offset, dom);
803 }
804
805 private long localizedWeekOfYear(TemporalAccessor temporal) {
806 int dow = localizedDayOfWeek(temporal);
807 int doy = temporal.get(DAY_OF_YEAR);
808 int offset = startOfWeekOffset(doy, dow);
809 return computeWeek(offset, doy);
810 }
811
812 /**
813 * Returns the year of week-based-year for the temporal.
814 * The year can be the previous year, the current year, or the next year.
815 * @param temporal a date of any chronology, not null
816 * @return the year of week-based-year for the date
817 */
818 private int localizedWeekBasedYear(TemporalAccessor temporal) {
819 int dow = localizedDayOfWeek(temporal);
820 int year = temporal.get(YEAR);
821 int doy = temporal.get(DAY_OF_YEAR);
822 int offset = startOfWeekOffset(doy, dow);
823 int week = computeWeek(offset, doy);
824 if (week == 0) {
825 // Day is in end of week of previous year; return the previous year
826 return year - 1;
827 } else {
828 // If getting close to end of year, use higher precision logic
829 // Check if date of year is in partial week associated with next year
830 ValueRange dayRange = temporal.range(DAY_OF_YEAR);
831 int yearLen = (int)dayRange.getMaximum();
832 int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());
833 if (week >= newYearWeek) {
834 return year + 1;
835 }
836 }
837 return year;
838 }
839
840 /**
841 * Returns the week of week-based-year for the temporal.
842 * The week can be part of the previous year, the current year,
843 * or the next year depending on the week start and minimum number
844 * of days.
845 * @param temporal a date of any chronology
846 * @return the week of the year
847 * @see #localizedWeekBasedYear(java.time.temporal.TemporalAccessor)
848 */
849 private int localizedWeekOfWeekBasedYear(TemporalAccessor temporal) {
850 int dow = localizedDayOfWeek(temporal);
851 int doy = temporal.get(DAY_OF_YEAR);
852 int offset = startOfWeekOffset(doy, dow);
853 int week = computeWeek(offset, doy);
854 if (week == 0) {
855 // Day is in end of week of previous year
856 // Recompute from the last day of the previous year
857 ChronoLocalDate date = Chronology.from(temporal).date(temporal);
858 date = date.minus(doy, DAYS); // Back down into previous year
859 return localizedWeekOfWeekBasedYear(date);
860 } else if (week > 50) {
861 // If getting close to end of year, use higher precision logic
862 // Check if date of year is in partial week associated with next year
863 ValueRange dayRange = temporal.range(DAY_OF_YEAR);
864 int yearLen = (int)dayRange.getMaximum();
865 int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());
866 if (week >= newYearWeek) {
867 // Overlaps with week of following year; reduce to week in following year
868 week = week - newYearWeek + 1;
869 }
870 }
871 return week;
872 }
873
874 /**
875 * Returns an offset to align week start with a day of month or day of year.
876 *
877 * @param day the day; 1 through infinity
878 * @param dow the day of the week of that day; 1 through 7
879 * @return an offset in days to align a day with the start of the first 'full' week
880 */
881 private int startOfWeekOffset(int day, int dow) {
882 // offset of first day corresponding to the day of week in first 7 days (zero origin)
883 int weekStart = Math.floorMod(day - dow, 7);
884 int offset = -weekStart;
885 if (weekStart + 1 > weekDef.getMinimalDaysInFirstWeek()) {
886 // The previous week has the minimum days in the current month to be a 'week'
887 offset = 7 - weekStart;
888 }
889 return offset;
890 }
891
892 /**
893 * Returns the week number computed from the reference day and reference dayOfWeek.
894 *
895 * @param offset the offset to align a date with the start of week
896 * from {@link #startOfWeekOffset}.
897 * @param day the day for which to compute the week number
898 * @return the week number where zero is used for a partial week and 1 for the first full week
899 */
900 private int computeWeek(int offset, int day) {
901 return ((7 + offset + (day - 1)) / 7);
902 }
903
904 @SuppressWarnings("unchecked")
905 @Override
906 public <R extends Temporal> R adjustInto(R temporal, long newValue) {
907 // Check the new value and get the old value of the field
908 int newVal = range.checkValidIntValue(newValue, this); // lenient check range
909 int currentVal = temporal.get(this);
910 if (newVal == currentVal) {
911 return temporal;
912 }
913
914 if (rangeUnit == FOREVER) { // replace year of WeekBasedYear
915 // Create a new date object with the same chronology,
916 // the desired year and the same week and dow.
917 int idow = temporal.get(weekDef.dayOfWeek);
918 int wowby = temporal.get(weekDef.weekOfWeekBasedYear);
919 return (R) ofWeekBasedYear(Chronology.from(temporal), (int)newValue, wowby, idow);
920 } else {
921 // Compute the difference and add that using the base unit of the field
922 return (R) temporal.plus(newVal - currentVal, baseUnit);
923 }
924 }
925
926 @Override
927 public ChronoLocalDate resolve(
928 Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) {
929 final long value = fieldValues.get(this);
930 final int newValue = Math.toIntExact(value); // broad limit makes overflow checking lighter
931 // first convert localized day-of-week to ISO day-of-week
932 // doing this first handles case where both ISO and localized were parsed and might mismatch
933 // day-of-week is always strict as two different day-of-week values makes lenient complex
934 if (rangeUnit == WEEKS) { // day-of-week
935 final int checkedValue = range.checkValidIntValue(value, this); // no leniency as too complex
936 final int startDow = weekDef.getFirstDayOfWeek().getValue();
937 long isoDow = Math.floorMod((startDow - 1) + (checkedValue - 1), 7) + 1;
938 fieldValues.remove(this);
939 fieldValues.put(DAY_OF_WEEK, isoDow);
940 return null;
941 }
942
943 // can only build date if ISO day-of-week is present
944 if (fieldValues.containsKey(DAY_OF_WEEK) == false) {
945 return null;
946 }
947 int isoDow = DAY_OF_WEEK.checkValidIntValue(fieldValues.get(DAY_OF_WEEK));
948 int dow = localizedDayOfWeek(isoDow);
949
950 // build date
951 Chronology chrono = Chronology.from(partialTemporal);
952 if (fieldValues.containsKey(YEAR)) {
953 int year = YEAR.checkValidIntValue(fieldValues.get(YEAR)); // validate
954 if (rangeUnit == MONTHS && fieldValues.containsKey(MONTH_OF_YEAR)) { // week-of-month
955 long month = fieldValues.get(MONTH_OF_YEAR); // not validated yet
956 return resolveWoM(fieldValues, chrono, year, month, newValue, dow, resolverStyle);
957 }
958 if (rangeUnit == YEARS) { // week-of-year
959 return resolveWoY(fieldValues, chrono, year, newValue, dow, resolverStyle);
960 }
961 } else if ((rangeUnit == WEEK_BASED_YEARS || rangeUnit == FOREVER) &&
962 fieldValues.containsKey(weekDef.weekBasedYear) &&
963 fieldValues.containsKey(weekDef.weekOfWeekBasedYear)) { // week-of-week-based-year and year-of-week-based-year
964 return resolveWBY(fieldValues, chrono, dow, resolverStyle);
965 }
966 return null;
967 }
968
969 private ChronoLocalDate resolveWoM(
970 Map<TemporalField, Long> fieldValues, Chronology chrono, int year, long month, long wom, int localDow, ResolverStyle resolverStyle) {
971 ChronoLocalDate date;
972 if (resolverStyle == ResolverStyle.LENIENT) {
973 date = chrono.date(year, 1, 1).plus(Math.subtractExact(month, 1), MONTHS);
974 long weeks = Math.subtractExact(wom, localizedWeekOfMonth(date));
975 int days = localDow - localizedDayOfWeek(date); // safe from overflow
976 date = date.plus(Math.addExact(Math.multiplyExact(weeks, 7), days), DAYS);
977 } else {
978 int monthValid = MONTH_OF_YEAR.checkValidIntValue(month); // validate
979 date = chrono.date(year, monthValid, 1);
980 int womInt = range.checkValidIntValue(wom, this); // validate
981 int weeks = (int) (womInt - localizedWeekOfMonth(date)); // safe from overflow
982 int days = localDow - localizedDayOfWeek(date); // safe from overflow
983 date = date.plus(weeks * 7 + days, DAYS);
984 if (resolverStyle == ResolverStyle.STRICT && date.getLong(MONTH_OF_YEAR) != month) {
985 throw new DateTimeException("Strict mode rejected resolved date as it is in a different month");
986 }
987 }
988 fieldValues.remove(this);
989 fieldValues.remove(YEAR);
990 fieldValues.remove(MONTH_OF_YEAR);
991 fieldValues.remove(DAY_OF_WEEK);
992 return date;
993 }
994
995 private ChronoLocalDate resolveWoY(
996 Map<TemporalField, Long> fieldValues, Chronology chrono, int year, long woy, int localDow, ResolverStyle resolverStyle) {
997 ChronoLocalDate date = chrono.date(year, 1, 1);
998 if (resolverStyle == ResolverStyle.LENIENT) {
999 long weeks = Math.subtractExact(woy, localizedWeekOfYear(date));
1000 int days = localDow - localizedDayOfWeek(date); // safe from overflow
1001 date = date.plus(Math.addExact(Math.multiplyExact(weeks, 7), days), DAYS);
1002 } else {
1003 int womInt = range.checkValidIntValue(woy, this); // validate
1004 int weeks = (int) (womInt - localizedWeekOfYear(date)); // safe from overflow
1005 int days = localDow - localizedDayOfWeek(date); // safe from overflow
1006 date = date.plus(weeks * 7 + days, DAYS);
1007 if (resolverStyle == ResolverStyle.STRICT && date.getLong(YEAR) != year) {
1008 throw new DateTimeException("Strict mode rejected resolved date as it is in a different year");
1009 }
1010 }
1011 fieldValues.remove(this);
1012 fieldValues.remove(YEAR);
1013 fieldValues.remove(DAY_OF_WEEK);
1014 return date;
1015 }
1016
1017 private ChronoLocalDate resolveWBY(
1018 Map<TemporalField, Long> fieldValues, Chronology chrono, int localDow, ResolverStyle resolverStyle) {
1019 int yowby = weekDef.weekBasedYear.range().checkValidIntValue(
1020 fieldValues.get(weekDef.weekBasedYear), weekDef.weekBasedYear);
1021 ChronoLocalDate date;
1022 if (resolverStyle == ResolverStyle.LENIENT) {
1023 date = ofWeekBasedYear(chrono, yowby, 1, localDow);
1024 long wowby = fieldValues.get(weekDef.weekOfWeekBasedYear);
1025 long weeks = Math.subtractExact(wowby, 1);
1026 date = date.plus(weeks, WEEKS);
1027 } else {
1028 int wowby = weekDef.weekOfWeekBasedYear.range().checkValidIntValue(
1029 fieldValues.get(weekDef.weekOfWeekBasedYear), weekDef.weekOfWeekBasedYear); // validate
1030 date = ofWeekBasedYear(chrono, yowby, wowby, localDow);
1031 if (resolverStyle == ResolverStyle.STRICT && localizedWeekBasedYear(date) != yowby) {
1032 throw new DateTimeException("Strict mode rejected resolved date as it is in a different week-based-year");
1033 }
1034 }
1035 fieldValues.remove(this);
1036 fieldValues.remove(weekDef.weekBasedYear);
1037 fieldValues.remove(weekDef.weekOfWeekBasedYear);
1038 fieldValues.remove(DAY_OF_WEEK);
1039 return date;
1040 }
1041
1042 //-----------------------------------------------------------------------
1043 @Override
1044 public String getDisplayName(Locale locale) {
1045 Objects.requireNonNull(locale, "locale");
1046 if (rangeUnit == YEARS) { // only have values for week-of-year
1047 LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased()
1048 .getLocaleResources(
1049 CalendarDataUtility.findRegionOverride(locale));
1050 ResourceBundle rb = lr.getJavaTimeFormatData();
1051 return rb.containsKey("field.week") ? rb.getString("field.week") : name;
1052 }
1053 return name;
1054 }
1055
1056 @Override
1057 public TemporalUnit getBaseUnit() {
1058 return baseUnit;
1059 }
1060
1061 @Override
1062 public TemporalUnit getRangeUnit() {
1063 return rangeUnit;
1064 }
1065
1066 @Override
1067 public boolean isDateBased() {
1068 return true;
1069 }
1070
1071 @Override
1072 public boolean isTimeBased() {
1073 return false;
1074 }
1075
1076 @Override
1077 public ValueRange range() {
1078 return range;
1079 }
1080
1081 //-----------------------------------------------------------------------
1082 @Override
1083 public boolean isSupportedBy(TemporalAccessor temporal) {
1084 if (temporal.isSupported(DAY_OF_WEEK)) {
1085 if (rangeUnit == WEEKS) { // day-of-week
1086 return true;
1087 } else if (rangeUnit == MONTHS) { // week-of-month
1088 return temporal.isSupported(DAY_OF_MONTH);
1089 } else if (rangeUnit == YEARS) { // week-of-year
1090 return temporal.isSupported(DAY_OF_YEAR);
1091 } else if (rangeUnit == WEEK_BASED_YEARS) {
1092 return temporal.isSupported(DAY_OF_YEAR);
1093 } else if (rangeUnit == FOREVER) {
1094 return temporal.isSupported(YEAR);
1095 }
1096 }
1097 return false;
1098 }
1099
1100 @Override
1101 public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
1102 if (rangeUnit == ChronoUnit.WEEKS) { // day-of-week
1103 return range;
1104 } else if (rangeUnit == MONTHS) { // week-of-month
1105 return rangeByWeek(temporal, DAY_OF_MONTH);
1106 } else if (rangeUnit == YEARS) { // week-of-year
1107 return rangeByWeek(temporal, DAY_OF_YEAR);
1108 } else if (rangeUnit == WEEK_BASED_YEARS) {
1109 return rangeWeekOfWeekBasedYear(temporal);
1110 } else if (rangeUnit == FOREVER) {
1111 return YEAR.range();
1112 } else {
1113 throw new IllegalStateException("unreachable, rangeUnit: " + rangeUnit + ", this: " + this);
1114 }
1115 }
1116
1117 /**
1118 * Map the field range to a week range
1119 * @param temporal the temporal
1120 * @param field the field to get the range of
1121 * @return the ValueRange with the range adjusted to weeks.
1122 */
1123 private ValueRange rangeByWeek(TemporalAccessor temporal, TemporalField field) {
1124 int dow = localizedDayOfWeek(temporal);
1125 int offset = startOfWeekOffset(temporal.get(field), dow);
1126 ValueRange fieldRange = temporal.range(field);
1127 return ValueRange.of(computeWeek(offset, (int) fieldRange.getMinimum()),
1128 computeWeek(offset, (int) fieldRange.getMaximum()));
1129 }
1130
1131 /**
1132 * Map the field range to a week range of a week year.
1133 * @param temporal the temporal
1134 * @return the ValueRange with the range adjusted to weeks.
1135 */
1136 private ValueRange rangeWeekOfWeekBasedYear(TemporalAccessor temporal) {
1137 if (!temporal.isSupported(DAY_OF_YEAR)) {
1138 return WEEK_OF_YEAR_RANGE;
1139 }
1140 int dow = localizedDayOfWeek(temporal);
1141 int doy = temporal.get(DAY_OF_YEAR);
1142 int offset = startOfWeekOffset(doy, dow);
1143 int week = computeWeek(offset, doy);
1144 if (week == 0) {
1145 // Day is in end of week of previous year
1146 // Recompute from the last day of the previous year
1147 ChronoLocalDate date = Chronology.from(temporal).date(temporal);
1148 date = date.minus(doy + 7, DAYS); // Back down into previous year
1149 return rangeWeekOfWeekBasedYear(date);
1150 }
1151 // Check if day of year is in partial week associated with next year
1152 ValueRange dayRange = temporal.range(DAY_OF_YEAR);
1153 int yearLen = (int)dayRange.getMaximum();
1154 int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());
1155
1156 if (week >= newYearWeek) {
1157 // Overlaps with weeks of following year; recompute from a week in following year
1158 ChronoLocalDate date = Chronology.from(temporal).date(temporal);
1159 date = date.plus(yearLen - doy + 1 + 7, ChronoUnit.DAYS);
1160 return rangeWeekOfWeekBasedYear(date);
1161 }
1162 return ValueRange.of(1, newYearWeek-1);
1163 }
1164
1165 //-----------------------------------------------------------------------
1166 @Override
1167 public String toString() {
1168 return name + "[" + weekDef.toString() + "]";
1169 }
1170 }
1171 }
1172