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 * Copyright (c) 2012, Stephen Colebourne & Michael Nascimento Santos
28 *
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions are met:
33 *
34 * * Redistributions of source code must retain the above copyright notice,
35 * this list of conditions and the following disclaimer.
36 *
37 * * Redistributions in binary form must reproduce the above copyright notice,
38 * this list of conditions and the following disclaimer in the documentation
39 * and/or other materials provided with the distribution.
40 *
41 * * Neither the name of JSR-310 nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
46 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
47 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
48 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
49 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
50 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
53 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
54 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
55 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 */
57
58 package java.time.chrono;
59
60 import static java.time.temporal.ChronoField.EPOCH_DAY;
61
62 import java.io.FilePermission;
63 import java.io.InputStream;
64 import java.io.InvalidObjectException;
65 import java.io.ObjectInputStream;
66 import java.io.Serializable;
67 import java.security.AccessController;
68 import java.security.PrivilegedAction;
69 import java.time.Clock;
70 import java.time.DateTimeException;
71 import java.time.Instant;
72 import java.time.LocalDate;
73 import java.time.ZoneId;
74 import java.time.format.ResolverStyle;
75 import java.time.temporal.ChronoField;
76 import java.time.temporal.TemporalAccessor;
77 import java.time.temporal.TemporalField;
78 import java.time.temporal.ValueRange;
79 import java.util.Arrays;
80 import java.util.HashMap;
81 import java.util.List;
82 import java.util.Map;
83 import java.util.Properties;
84
85 import sun.util.logging.PlatformLogger;
86
87 /**
88 * The Hijrah calendar is a lunar calendar supporting Islamic calendars.
89 * <p>
90 * The HijrahChronology follows the rules of the Hijrah calendar system. The Hijrah
91 * calendar has several variants based on differences in when the new moon is
92 * determined to have occurred and where the observation is made.
93 * In some variants the length of each month is
94 * computed algorithmically from the astronomical data for the moon and earth and
95 * in others the length of the month is determined by an authorized sighting
96 * of the new moon. For the algorithmically based calendars the calendar
97 * can project into the future.
98 * For sighting based calendars only historical data from past
99 * sightings is available.
100 * <p>
101 * The length of each month is 29 or 30 days.
102 * Ordinary years have 354 days; leap years have 355 days.
103 *
104 * <p>
105 * CLDR and LDML identify variants:
106 * <table class="striped" style="text-align:left">
107 * <caption style="display:none">Variants of Hijrah Calendars</caption>
108 * <thead>
109 * <tr>
110 * <th scope="col">Chronology ID</th>
111 * <th scope="col">Calendar Type</th>
112 * <th scope="col">Locale extension, see {@link java.util.Locale}</th>
113 * <th scope="col">Description</th>
114 * </tr>
115 * </thead>
116 * <tbody>
117 * <tr>
118 * <th scope="row">Hijrah-umalqura</th>
119 * <td>islamic-umalqura</td>
120 * <td>ca-islamic-umalqura</td>
121 * <td>Islamic - Umm Al-Qura calendar of Saudi Arabia</td>
122 * </tr>
123 * </tbody>
124 * </table>
125 * <p>Additional variants may be available through {@link Chronology#getAvailableChronologies()}.
126 *
127 * <p>Example</p>
128 * <p>
129 * Selecting the chronology from the locale uses {@link Chronology#ofLocale}
130 * to find the Chronology based on Locale supported BCP 47 extension mechanism
131 * to request a specific calendar ("ca"). For example,
132 * </p>
133 * <pre>
134 * Locale locale = Locale.forLanguageTag("en-US-u-ca-islamic-umalqura");
135 * Chronology chrono = Chronology.ofLocale(locale);
136 * </pre>
137 *
138 * @implSpec
139 * This class is immutable and thread-safe.
140 *
141 * @implNote
142 * Each Hijrah variant is configured individually. Each variant is defined by a
143 * property resource that defines the {@code ID}, the {@code calendar type},
144 * the start of the calendar, the alignment with the
145 * ISO calendar, and the length of each month for a range of years.
146 * The variants are loaded by HijrahChronology as a resource from
147 * hijrah-config-<calendar type>.properties.
148 * <p>
149 * The Hijrah property resource is a set of properties that describe the calendar.
150 * The syntax is defined by {@code java.util.Properties#load(Reader)}.
151 * <table class="striped" style="text-align:left">
152 * <caption style="display:none">Configuration of Hijrah Calendar</caption>
153 * <thead>
154 * <tr>
155 * <th scope="col">Property Name</th>
156 * <th scope="col">Property value</th>
157 * <th scope="col">Description</th>
158 * </tr>
159 * </thead>
160 * <tbody>
161 * <tr>
162 * <th scope="row">id</th>
163 * <td>Chronology Id, for example, "Hijrah-umalqura"</td>
164 * <td>The Id of the calendar in common usage</td>
165 * </tr>
166 * <tr>
167 * <th scope="row">type</th>
168 * <td>Calendar type, for example, "islamic-umalqura"</td>
169 * <td>LDML defines the calendar types</td>
170 * </tr>
171 * <tr>
172 * <th scope="row">version</th>
173 * <td>Version, for example: "1.8.0_1"</td>
174 * <td>The version of the Hijrah variant data</td>
175 * </tr>
176 * <tr>
177 * <th scope="row">iso-start</th>
178 * <td>ISO start date, formatted as {@code yyyy-MM-dd}, for example: "1900-04-30"</td>
179 * <td>The ISO date of the first day of the minimum Hijrah year.</td>
180 * </tr>
181 * <tr>
182 * <th scope="row">yyyy - a numeric 4 digit year, for example "1434"</th>
183 * <td>The value is a sequence of 12 month lengths,
184 * for example: "29 30 29 30 29 30 30 30 29 30 29 29"</td>
185 * <td>The lengths of the 12 months of the year separated by whitespace.
186 * A numeric year property must be present for every year without any gaps.
187 * The month lengths must be between 29-32 inclusive.
188 * </td>
189 * </tr>
190 * </tbody>
191 * </table>
192 *
193 * @since 1.8
194 */
195 public final class HijrahChronology extends AbstractChronology implements Serializable {
196
197 /**
198 * The Hijrah Calendar id.
199 */
200 private final transient String typeId;
201 /**
202 * The Hijrah calendarType.
203 */
204 private final transient String calendarType;
205 /**
206 * Serialization version.
207 */
208 private static final long serialVersionUID = 3127340209035924785L;
209 /**
210 * Singleton instance of the Islamic Umm Al-Qura calendar of Saudi Arabia.
211 * Other Hijrah chronology variants may be available from
212 * {@link Chronology#getAvailableChronologies}.
213 */
214 public static final HijrahChronology INSTANCE;
215 /**
216 * Flag to indicate the initialization of configuration data is complete.
217 * @see #checkCalendarInit()
218 */
219 private transient volatile boolean initComplete;
220 /**
221 * Array of epoch days indexed by Hijrah Epoch month.
222 * Computed by {@link #loadCalendarData}.
223 */
224 private transient int[] hijrahEpochMonthStartDays;
225 /**
226 * The minimum epoch day of this Hijrah calendar.
227 * Computed by {@link #loadCalendarData}.
228 */
229 private transient int minEpochDay;
230 /**
231 * The maximum epoch day for which calendar data is available.
232 * Computed by {@link #loadCalendarData}.
233 */
234 private transient int maxEpochDay;
235 /**
236 * The minimum epoch month.
237 * Computed by {@link #loadCalendarData}.
238 */
239 private transient int hijrahStartEpochMonth;
240 /**
241 * The minimum length of a month.
242 * Computed by {@link #createEpochMonths}.
243 */
244 private transient int minMonthLength;
245 /**
246 * The maximum length of a month.
247 * Computed by {@link #createEpochMonths}.
248 */
249 private transient int maxMonthLength;
250 /**
251 * The minimum length of a year in days.
252 * Computed by {@link #createEpochMonths}.
253 */
254 private transient int minYearLength;
255 /**
256 * The maximum length of a year in days.
257 * Computed by {@link #createEpochMonths}.
258 */
259 private transient int maxYearLength;
260
261 /**
262 * Prefix of resource names for Hijrah calendar variants.
263 */
264 private static final String RESOURCE_PREFIX = "hijrah-config-";
265
266 /**
267 * Suffix of resource names for Hijrah calendar variants.
268 */
269 private static final String RESOURCE_SUFFIX = ".properties";
270
271 /**
272 * Static initialization of the built-in calendars.
273 * The data is not loaded until it is used.
274 */
275 static {
276 INSTANCE = new HijrahChronology("Hijrah-umalqura", "islamic-umalqura");
277 // Register it by its aliases
278 AbstractChronology.registerChrono(INSTANCE, "Hijrah");
279 AbstractChronology.registerChrono(INSTANCE, "islamic");
280 }
281
282 /**
283 * Create a HijrahChronology for the named variant and type.
284 *
285 * @param id the id of the calendar
286 * @param calType the typeId of the calendar
287 * @throws IllegalArgumentException if the id or typeId is empty
288 */
289 private HijrahChronology(String id, String calType) {
290 if (id.isEmpty()) {
291 throw new IllegalArgumentException("calendar id is empty");
292 }
293 if (calType.isEmpty()) {
294 throw new IllegalArgumentException("calendar typeId is empty");
295 }
296 this.typeId = id;
297 this.calendarType = calType;
298 }
299
300 /**
301 * Check and ensure that the calendar data has been initialized.
302 * The initialization check is performed at the boundary between
303 * public and package methods. If a public calls another public method
304 * a check is not necessary in the caller.
305 * The constructors of HijrahDate call {@link #getEpochDay} or
306 * {@link #getHijrahDateInfo} so every call from HijrahDate to a
307 * HijrahChronology via package private methods has been checked.
308 *
309 * @throws DateTimeException if the calendar data configuration is
310 * malformed or IOExceptions occur loading the data
311 */
312 private void checkCalendarInit() {
313 // Keep this short so it can be inlined for performance
314 if (initComplete == false) {
315 loadCalendarData();
316 initComplete = true;
317 }
318 }
319
320 //-----------------------------------------------------------------------
321 /**
322 * Gets the ID of the chronology.
323 * <p>
324 * The ID uniquely identifies the {@code Chronology}. It can be used to
325 * lookup the {@code Chronology} using {@link Chronology#of(String)}.
326 *
327 * @return the chronology ID, non-null
328 * @see #getCalendarType()
329 */
330 @Override
331 public String getId() {
332 return typeId;
333 }
334
335 /**
336 * Gets the calendar type of the Islamic calendar.
337 * <p>
338 * The calendar type is an identifier defined by the
339 * <em>Unicode Locale Data Markup Language (LDML)</em> specification.
340 * It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}.
341 *
342 * @return the calendar system type; non-null if the calendar has
343 * a standard type, otherwise null
344 * @see #getId()
345 */
346 @Override
347 public String getCalendarType() {
348 return calendarType;
349 }
350
351 //-----------------------------------------------------------------------
352 /**
353 * Obtains a local date in Hijrah calendar system from the
354 * era, year-of-era, month-of-year and day-of-month fields.
355 *
356 * @param era the Hijrah era, not null
357 * @param yearOfEra the year-of-era
358 * @param month the month-of-year
359 * @param dayOfMonth the day-of-month
360 * @return the Hijrah local date, not null
361 * @throws DateTimeException if unable to create the date
362 * @throws ClassCastException if the {@code era} is not a {@code HijrahEra}
363 */
364 @Override
365 public HijrahDate date(Era era, int yearOfEra, int month, int dayOfMonth) {
366 return date(prolepticYear(era, yearOfEra), month, dayOfMonth);
367 }
368
369 /**
370 * Obtains a local date in Hijrah calendar system from the
371 * proleptic-year, month-of-year and day-of-month fields.
372 *
373 * @param prolepticYear the proleptic-year
374 * @param month the month-of-year
375 * @param dayOfMonth the day-of-month
376 * @return the Hijrah local date, not null
377 * @throws DateTimeException if unable to create the date
378 */
379 @Override
380 public HijrahDate date(int prolepticYear, int month, int dayOfMonth) {
381 return HijrahDate.of(this, prolepticYear, month, dayOfMonth);
382 }
383
384 /**
385 * Obtains a local date in Hijrah calendar system from the
386 * era, year-of-era and day-of-year fields.
387 *
388 * @param era the Hijrah era, not null
389 * @param yearOfEra the year-of-era
390 * @param dayOfYear the day-of-year
391 * @return the Hijrah local date, not null
392 * @throws DateTimeException if unable to create the date
393 * @throws ClassCastException if the {@code era} is not a {@code HijrahEra}
394 */
395 @Override
396 public HijrahDate dateYearDay(Era era, int yearOfEra, int dayOfYear) {
397 return dateYearDay(prolepticYear(era, yearOfEra), dayOfYear);
398 }
399
400 /**
401 * Obtains a local date in Hijrah calendar system from the
402 * proleptic-year and day-of-year fields.
403 *
404 * @param prolepticYear the proleptic-year
405 * @param dayOfYear the day-of-year
406 * @return the Hijrah local date, not null
407 * @throws DateTimeException if the value of the year is out of range,
408 * or if the day-of-year is invalid for the year
409 */
410 @Override
411 public HijrahDate dateYearDay(int prolepticYear, int dayOfYear) {
412 HijrahDate date = HijrahDate.of(this, prolepticYear, 1, 1);
413 if (dayOfYear > date.lengthOfYear()) {
414 throw new DateTimeException("Invalid dayOfYear: " + dayOfYear);
415 }
416 return date.plusDays(dayOfYear - 1);
417 }
418
419 /**
420 * Obtains a local date in the Hijrah calendar system from the epoch-day.
421 *
422 * @param epochDay the epoch day
423 * @return the Hijrah local date, not null
424 * @throws DateTimeException if unable to create the date
425 */
426 @Override // override with covariant return type
427 public HijrahDate dateEpochDay(long epochDay) {
428 return HijrahDate.ofEpochDay(this, epochDay);
429 }
430
431 @Override
432 public HijrahDate dateNow() {
433 return dateNow(Clock.systemDefaultZone());
434 }
435
436 @Override
437 public HijrahDate dateNow(ZoneId zone) {
438 return dateNow(Clock.system(zone));
439 }
440
441 @Override
442 public HijrahDate dateNow(Clock clock) {
443 return date(LocalDate.now(clock));
444 }
445
446 @Override
447 public HijrahDate date(TemporalAccessor temporal) {
448 if (temporal instanceof HijrahDate) {
449 return (HijrahDate) temporal;
450 }
451 return HijrahDate.ofEpochDay(this, temporal.getLong(EPOCH_DAY));
452 }
453
454 @Override
455 @SuppressWarnings("unchecked")
456 public ChronoLocalDateTime<HijrahDate> localDateTime(TemporalAccessor temporal) {
457 return (ChronoLocalDateTime<HijrahDate>) super.localDateTime(temporal);
458 }
459
460 @Override
461 @SuppressWarnings("unchecked")
462 public ChronoZonedDateTime<HijrahDate> zonedDateTime(TemporalAccessor temporal) {
463 return (ChronoZonedDateTime<HijrahDate>) super.zonedDateTime(temporal);
464 }
465
466 @Override
467 @SuppressWarnings("unchecked")
468 public ChronoZonedDateTime<HijrahDate> zonedDateTime(Instant instant, ZoneId zone) {
469 return (ChronoZonedDateTime<HijrahDate>) super.zonedDateTime(instant, zone);
470 }
471
472 //-----------------------------------------------------------------------
473 @Override
474 public boolean isLeapYear(long prolepticYear) {
475 checkCalendarInit();
476 if (prolepticYear < getMinimumYear() || prolepticYear > getMaximumYear()) {
477 return false;
478 }
479 int len = getYearLength((int) prolepticYear);
480 return (len > 354);
481 }
482
483 @Override
484 public int prolepticYear(Era era, int yearOfEra) {
485 if (era instanceof HijrahEra == false) {
486 throw new ClassCastException("Era must be HijrahEra");
487 }
488 return yearOfEra;
489 }
490
491 /**
492 * Creates the HijrahEra object from the numeric value.
493 * The Hijrah calendar system has only one era covering the
494 * proleptic years greater than zero.
495 * This method returns the singleton HijrahEra for the value 1.
496 *
497 * @param eraValue the era value
498 * @return the calendar system era, not null
499 * @throws DateTimeException if unable to create the era
500 */
501 @Override
502 public HijrahEra eraOf(int eraValue) {
503 switch (eraValue) {
504 case 1:
505 return HijrahEra.AH;
506 default:
507 throw new DateTimeException("invalid Hijrah era");
508 }
509 }
510
511 @Override
512 public List<Era> eras() {
513 return List.of(HijrahEra.values());
514 }
515
516 //-----------------------------------------------------------------------
517 @Override
518 public ValueRange range(ChronoField field) {
519 checkCalendarInit();
520 if (field instanceof ChronoField) {
521 ChronoField f = field;
522 switch (f) {
523 case DAY_OF_MONTH:
524 return ValueRange.of(1, 1, getMinimumMonthLength(), getMaximumMonthLength());
525 case DAY_OF_YEAR:
526 return ValueRange.of(1, getMaximumDayOfYear());
527 case ALIGNED_WEEK_OF_MONTH:
528 return ValueRange.of(1, 5);
529 case YEAR:
530 case YEAR_OF_ERA:
531 return ValueRange.of(getMinimumYear(), getMaximumYear());
532 case ERA:
533 return ValueRange.of(1, 1);
534 default:
535 return field.range();
536 }
537 }
538 return field.range();
539 }
540
541 //-----------------------------------------------------------------------
542 @Override // override for return type
543 public HijrahDate resolveDate(Map<TemporalField, Long> fieldValues, ResolverStyle resolverStyle) {
544 return (HijrahDate) super.resolveDate(fieldValues, resolverStyle);
545 }
546
547 //-----------------------------------------------------------------------
548 /**
549 * Check the validity of a year.
550 *
551 * @param prolepticYear the year to check
552 */
553 int checkValidYear(long prolepticYear) {
554 if (prolepticYear < getMinimumYear() || prolepticYear > getMaximumYear()) {
555 throw new DateTimeException("Invalid Hijrah year: " + prolepticYear);
556 }
557 return (int) prolepticYear;
558 }
559
560 void checkValidDayOfYear(int dayOfYear) {
561 if (dayOfYear < 1 || dayOfYear > getMaximumDayOfYear()) {
562 throw new DateTimeException("Invalid Hijrah day of year: " + dayOfYear);
563 }
564 }
565
566 void checkValidMonth(int month) {
567 if (month < 1 || month > 12) {
568 throw new DateTimeException("Invalid Hijrah month: " + month);
569 }
570 }
571
572 //-----------------------------------------------------------------------
573 /**
574 * Returns an array containing the Hijrah year, month and day
575 * computed from the epoch day.
576 *
577 * @param epochDay the EpochDay
578 * @return int[0] = YEAR, int[1] = MONTH, int[2] = DATE
579 */
580 int[] getHijrahDateInfo(int epochDay) {
581 checkCalendarInit(); // ensure that the chronology is initialized
582 if (epochDay < minEpochDay || epochDay >= maxEpochDay) {
583 throw new DateTimeException("Hijrah date out of range");
584 }
585
586 int epochMonth = epochDayToEpochMonth(epochDay);
587 int year = epochMonthToYear(epochMonth);
588 int month = epochMonthToMonth(epochMonth);
589 int day1 = epochMonthToEpochDay(epochMonth);
590 int date = epochDay - day1; // epochDay - dayOfEpoch(year, month);
591
592 int dateInfo[] = new int[3];
593 dateInfo[0] = year;
594 dateInfo[1] = month + 1; // change to 1-based.
595 dateInfo[2] = date + 1; // change to 1-based.
596 return dateInfo;
597 }
598
599 /**
600 * Return the epoch day computed from Hijrah year, month, and day.
601 *
602 * @param prolepticYear the year to represent, 0-origin
603 * @param monthOfYear the month-of-year to represent, 1-origin
604 * @param dayOfMonth the day-of-month to represent, 1-origin
605 * @return the epoch day
606 */
607 long getEpochDay(int prolepticYear, int monthOfYear, int dayOfMonth) {
608 checkCalendarInit(); // ensure that the chronology is initialized
609 checkValidMonth(monthOfYear);
610 int epochMonth = yearToEpochMonth(prolepticYear) + (monthOfYear - 1);
611 if (epochMonth < 0 || epochMonth >= hijrahEpochMonthStartDays.length) {
612 throw new DateTimeException("Invalid Hijrah date, year: " +
613 prolepticYear + ", month: " + monthOfYear);
614 }
615 if (dayOfMonth < 1 || dayOfMonth > getMonthLength(prolepticYear, monthOfYear)) {
616 throw new DateTimeException("Invalid Hijrah day of month: " + dayOfMonth);
617 }
618 return epochMonthToEpochDay(epochMonth) + (dayOfMonth - 1);
619 }
620
621 /**
622 * Returns day of year for the year and month.
623 *
624 * @param prolepticYear a proleptic year
625 * @param month a month, 1-origin
626 * @return the day of year, 1-origin
627 */
628 int getDayOfYear(int prolepticYear, int month) {
629 return yearMonthToDayOfYear(prolepticYear, (month - 1));
630 }
631
632 /**
633 * Returns month length for the year and month.
634 *
635 * @param prolepticYear a proleptic year
636 * @param monthOfYear a month, 1-origin.
637 * @return the length of the month
638 */
639 int getMonthLength(int prolepticYear, int monthOfYear) {
640 int epochMonth = yearToEpochMonth(prolepticYear) + (monthOfYear - 1);
641 if (epochMonth < 0 || epochMonth >= hijrahEpochMonthStartDays.length) {
642 throw new DateTimeException("Invalid Hijrah date, year: " +
643 prolepticYear + ", month: " + monthOfYear);
644 }
645 return epochMonthLength(epochMonth);
646 }
647
648 /**
649 * Returns year length.
650 * Note: The 12th month must exist in the data.
651 *
652 * @param prolepticYear a proleptic year
653 * @return year length in days
654 */
655 int getYearLength(int prolepticYear) {
656 return yearMonthToDayOfYear(prolepticYear, 12);
657 }
658
659 /**
660 * Return the minimum supported Hijrah year.
661 *
662 * @return the minimum
663 */
664 int getMinimumYear() {
665 return epochMonthToYear(0);
666 }
667
668 /**
669 * Return the maximum supported Hijrah year.
670 *
671 * @return the minimum
672 */
673 int getMaximumYear() {
674 return epochMonthToYear(hijrahEpochMonthStartDays.length - 1) - 1;
675 }
676
677 /**
678 * Returns maximum day-of-month.
679 *
680 * @return maximum day-of-month
681 */
682 int getMaximumMonthLength() {
683 return maxMonthLength;
684 }
685
686 /**
687 * Returns smallest maximum day-of-month.
688 *
689 * @return smallest maximum day-of-month
690 */
691 int getMinimumMonthLength() {
692 return minMonthLength;
693 }
694
695 /**
696 * Returns maximum day-of-year.
697 *
698 * @return maximum day-of-year
699 */
700 int getMaximumDayOfYear() {
701 return maxYearLength;
702 }
703
704 /**
705 * Returns smallest maximum day-of-year.
706 *
707 * @return smallest maximum day-of-year
708 */
709 int getSmallestMaximumDayOfYear() {
710 return minYearLength;
711 }
712
713 /**
714 * Returns the epochMonth found by locating the epochDay in the table. The
715 * epochMonth is the index in the table
716 *
717 * @param epochDay
718 * @return The index of the element of the start of the month containing the
719 * epochDay.
720 */
721 private int epochDayToEpochMonth(int epochDay) {
722 // binary search
723 int ndx = Arrays.binarySearch(hijrahEpochMonthStartDays, epochDay);
724 if (ndx < 0) {
725 ndx = -ndx - 2;
726 }
727 return ndx;
728 }
729
730 /**
731 * Returns the year computed from the epochMonth
732 *
733 * @param epochMonth the epochMonth
734 * @return the Hijrah Year
735 */
736 private int epochMonthToYear(int epochMonth) {
737 return (epochMonth + hijrahStartEpochMonth) / 12;
738 }
739
740 /**
741 * Returns the epochMonth for the Hijrah Year.
742 *
743 * @param year the HijrahYear
744 * @return the epochMonth for the beginning of the year.
745 */
746 private int yearToEpochMonth(int year) {
747 return (year * 12) - hijrahStartEpochMonth;
748 }
749
750 /**
751 * Returns the Hijrah month from the epochMonth.
752 *
753 * @param epochMonth the epochMonth
754 * @return the month of the Hijrah Year
755 */
756 private int epochMonthToMonth(int epochMonth) {
757 return (epochMonth + hijrahStartEpochMonth) % 12;
758 }
759
760 /**
761 * Returns the epochDay for the start of the epochMonth.
762 *
763 * @param epochMonth the epochMonth
764 * @return the epochDay for the start of the epochMonth.
765 */
766 private int epochMonthToEpochDay(int epochMonth) {
767 return hijrahEpochMonthStartDays[epochMonth];
768
769 }
770
771 /**
772 * Returns the day of year for the requested HijrahYear and month.
773 *
774 * @param prolepticYear the Hijrah year
775 * @param month the Hijrah month
776 * @return the day of year for the start of the month of the year
777 */
778 private int yearMonthToDayOfYear(int prolepticYear, int month) {
779 int epochMonthFirst = yearToEpochMonth(prolepticYear);
780 return epochMonthToEpochDay(epochMonthFirst + month)
781 - epochMonthToEpochDay(epochMonthFirst);
782 }
783
784 /**
785 * Returns the length of the epochMonth. It is computed from the start of
786 * the following month minus the start of the requested month.
787 *
788 * @param epochMonth the epochMonth; assumed to be within range
789 * @return the length in days of the epochMonth
790 */
791 private int epochMonthLength(int epochMonth) {
792 // The very last entry in the epochMonth table is not the start of a month
793 return hijrahEpochMonthStartDays[epochMonth + 1]
794 - hijrahEpochMonthStartDays[epochMonth];
795 }
796
797 //-----------------------------------------------------------------------
798 private static final String KEY_ID = "id";
799 private static final String KEY_TYPE = "type";
800 private static final String KEY_VERSION = "version";
801 private static final String KEY_ISO_START = "iso-start";
802
803 /**
804 * Return the configuration properties from the resource.
805 * <p>
806 * The location of the variant configuration resource is:
807 * <pre>
808 * "/java/time/chrono/hijrah-config-" + calendarType + ".properties"
809 * </pre>
810 *
811 * @param calendarType the calendarType of the calendar variant
812 * @return a Properties containing the properties read from the resource.
813 * @throws Exception if access to the property resource fails
814 */
815 private Properties readConfigProperties(final String calendarType) throws Exception {
816 String resourceName = RESOURCE_PREFIX + calendarType + RESOURCE_SUFFIX;
817 PrivilegedAction<InputStream> getResourceAction = () -> HijrahChronology.class.getResourceAsStream(resourceName);
818 FilePermission perm1 = new FilePermission("<<ALL FILES>>", "read");
819 RuntimePermission perm2 = new RuntimePermission("accessSystemModules");
820 try (InputStream is = AccessController.doPrivileged(getResourceAction, null, perm1, perm2)) {
821 if (is == null) {
822 throw new RuntimeException("Hijrah calendar resource not found: /java/time/chrono/" + resourceName);
823 }
824 Properties props = new Properties();
825 props.load(is);
826 return props;
827 }
828 }
829
830 /**
831 * Loads and processes the Hijrah calendar properties file for this calendarType.
832 * The starting Hijrah date and the corresponding ISO date are
833 * extracted and used to calculate the epochDate offset.
834 * The version number is identified and ignored.
835 * Everything else is the data for a year with containing the length of each
836 * of 12 months.
837 *
838 * @throws DateTimeException if initialization of the calendar data from the
839 * resource fails
840 */
841 private void loadCalendarData() {
842 try {
843 Properties props = readConfigProperties(calendarType);
844
845 Map<Integer, int[]> years = new HashMap<>();
846 int minYear = Integer.MAX_VALUE;
847 int maxYear = Integer.MIN_VALUE;
848 String id = null;
849 String type = null;
850 String version = null;
851 int isoStart = 0;
852 for (Map.Entry<Object, Object> entry : props.entrySet()) {
853 String key = (String) entry.getKey();
854 switch (key) {
855 case KEY_ID:
856 id = (String)entry.getValue();
857 break;
858 case KEY_TYPE:
859 type = (String)entry.getValue();
860 break;
861 case KEY_VERSION:
862 version = (String)entry.getValue();
863 break;
864 case KEY_ISO_START: {
865 int[] ymd = parseYMD((String) entry.getValue());
866 isoStart = (int) LocalDate.of(ymd[0], ymd[1], ymd[2]).toEpochDay();
867 break;
868 }
869 default:
870 try {
871 // Everything else is either a year or invalid
872 int year = Integer.parseInt(key);
873 int[] months = parseMonths((String) entry.getValue());
874 years.put(year, months);
875 maxYear = Math.max(maxYear, year);
876 minYear = Math.min(minYear, year);
877 } catch (NumberFormatException nfe) {
878 throw new IllegalArgumentException("bad key: " + key);
879 }
880 }
881 }
882
883 if (!getId().equals(id)) {
884 throw new IllegalArgumentException("Configuration is for a different calendar: " + id);
885 }
886 if (!getCalendarType().equals(type)) {
887 throw new IllegalArgumentException("Configuration is for a different calendar type: " + type);
888 }
889 if (version == null || version.isEmpty()) {
890 throw new IllegalArgumentException("Configuration does not contain a version");
891 }
892 if (isoStart == 0) {
893 throw new IllegalArgumentException("Configuration does not contain a ISO start date");
894 }
895
896 // Now create and validate the array of epochDays indexed by epochMonth
897 hijrahStartEpochMonth = minYear * 12;
898 minEpochDay = isoStart;
899 hijrahEpochMonthStartDays = createEpochMonths(minEpochDay, minYear, maxYear, years);
900 maxEpochDay = hijrahEpochMonthStartDays[hijrahEpochMonthStartDays.length - 1];
901
902 // Compute the min and max year length in days.
903 for (int year = minYear; year < maxYear; year++) {
904 int length = getYearLength(year);
905 minYearLength = Math.min(minYearLength, length);
906 maxYearLength = Math.max(maxYearLength, length);
907 }
908 } catch (Exception ex) {
909 // Log error and throw a DateTimeException
910 PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
911 logger.severe("Unable to initialize Hijrah calendar proxy: " + typeId, ex);
912 throw new DateTimeException("Unable to initialize HijrahCalendar: " + typeId, ex);
913 }
914 }
915
916 /**
917 * Converts the map of year to month lengths ranging from minYear to maxYear
918 * into a linear contiguous array of epochDays. The index is the hijrahMonth
919 * computed from year and month and offset by minYear. The value of each
920 * entry is the epochDay corresponding to the first day of the month.
921 *
922 * @param minYear The minimum year for which data is provided
923 * @param maxYear The maximum year for which data is provided
924 * @param years a Map of year to the array of 12 month lengths
925 * @return array of epochDays for each month from min to max
926 */
927 private int[] createEpochMonths(int epochDay, int minYear, int maxYear, Map<Integer, int[]> years) {
928 // Compute the size for the array of dates
929 int numMonths = (maxYear - minYear + 1) * 12 + 1;
930
931 // Initialize the running epochDay as the corresponding ISO Epoch day
932 int epochMonth = 0; // index into array of epochMonths
933 int[] epochMonths = new int[numMonths];
934 minMonthLength = Integer.MAX_VALUE;
935 maxMonthLength = Integer.MIN_VALUE;
936
937 // Only whole years are valid, any zero's in the array are illegal
938 for (int year = minYear; year <= maxYear; year++) {
939 int[] months = years.get(year);// must not be gaps
940 for (int month = 0; month < 12; month++) {
941 int length = months[month];
942 epochMonths[epochMonth++] = epochDay;
943
944 if (length < 29 || length > 32) {
945 throw new IllegalArgumentException("Invalid month length in year: " + minYear);
946 }
947 epochDay += length;
948 minMonthLength = Math.min(minMonthLength, length);
949 maxMonthLength = Math.max(maxMonthLength, length);
950 }
951 }
952
953 // Insert the final epochDay
954 epochMonths[epochMonth++] = epochDay;
955
956 if (epochMonth != epochMonths.length) {
957 throw new IllegalStateException("Did not fill epochMonths exactly: ndx = " + epochMonth
958 + " should be " + epochMonths.length);
959 }
960
961 return epochMonths;
962 }
963
964 /**
965 * Parses the 12 months lengths from a property value for a specific year.
966 *
967 * @param line the value of a year property
968 * @return an array of int[12] containing the 12 month lengths
969 * @throws IllegalArgumentException if the number of months is not 12
970 * @throws NumberFormatException if the 12 tokens are not numbers
971 */
972 private int[] parseMonths(String line) {
973 int[] months = new int[12];
974 String[] numbers = line.split("\\s");
975 if (numbers.length != 12) {
976 throw new IllegalArgumentException("wrong number of months on line: " + Arrays.toString(numbers) + "; count: " + numbers.length);
977 }
978 for (int i = 0; i < 12; i++) {
979 try {
980 months[i] = Integer.parseInt(numbers[i]);
981 } catch (NumberFormatException nfe) {
982 throw new IllegalArgumentException("bad key: " + numbers[i]);
983 }
984 }
985 return months;
986 }
987
988 /**
989 * Parse yyyy-MM-dd into a 3 element array [yyyy, mm, dd].
990 *
991 * @param string the input string
992 * @return the 3 element array with year, month, day
993 */
994 private int[] parseYMD(String string) {
995 // yyyy-MM-dd
996 string = string.trim();
997 try {
998 if (string.charAt(4) != '-' || string.charAt(7) != '-') {
999 throw new IllegalArgumentException("date must be yyyy-MM-dd");
1000 }
1001 int[] ymd = new int[3];
1002 ymd[0] = Integer.parseInt(string, 0, 4, 10);
1003 ymd[1] = Integer.parseInt(string, 5, 7, 10);
1004 ymd[2] = Integer.parseInt(string, 8, 10, 10);
1005 return ymd;
1006 } catch (NumberFormatException ex) {
1007 throw new IllegalArgumentException("date must be yyyy-MM-dd", ex);
1008 }
1009 }
1010
1011 //-----------------------------------------------------------------------
1012 /**
1013 * Writes the Chronology using a
1014 * <a href="../../../serialized-form.html#java.time.chrono.Ser">dedicated serialized form</a>.
1015 * @serialData
1016 * <pre>
1017 * out.writeByte(1); // identifies a Chronology
1018 * out.writeUTF(getId());
1019 * </pre>
1020 *
1021 * @return the instance of {@code Ser}, not null
1022 */
1023 @Override
1024 Object writeReplace() {
1025 return super.writeReplace();
1026 }
1027
1028 /**
1029 * Defend against malicious streams.
1030 *
1031 * @param s the stream to read
1032 * @throws InvalidObjectException always
1033 */
1034 private void readObject(ObjectInputStream s) throws InvalidObjectException {
1035 throw new InvalidObjectException("Deserialization via serialization delegate");
1036 }
1037 }
1038