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 }