1 /*

     2  * Copyright (c) 2012, 2013, 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 package java.time.calendar;

    58 

    59 import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH;

    60 import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR;

    61 import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_MONTH;

    62 import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_YEAR;

    63 import static java.time.temporal.ChronoField.DAY_OF_MONTH;

    64 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;

    65 import static java.time.temporal.ChronoField.YEAR;

    66 

    67 import java.io.IOException;

    68 import java.io.ObjectInput;

    69 import java.io.ObjectOutput;

    70 import java.io.Serializable;

    71 import java.time.DateTimeException;

    72 import java.time.DayOfWeek;

    73 import java.time.LocalDate;

    74 import java.time.temporal.ChronoField;

    75 import java.time.temporal.ChronoLocalDate;

    76 import java.time.temporal.TemporalField;

    77 import java.time.temporal.ValueRange;

    78 import java.util.Objects;

    79 

    80 /**

    81  * A date in the Hijrah calendar system.

    82  * <p>

    83  * This implements {@code ChronoLocalDate} for the {@link HijrahChrono Hijrah calendar}.

    84  * <p>

    85  * The Hijrah calendar has a different total of days in a year than

    86  * Gregorian calendar, and a month is based on the period of a complete

    87  * revolution of the moon around the earth (as between successive new moons).

    88  * The calendar cycles becomes longer and unstable, and sometimes a manual

    89  * adjustment (for entering deviation) is necessary for correctness

    90  * because of the complex algorithm.

    91  * <p>

    92  * HijrahDate supports the manual adjustment feature by providing a configuration

    93  * file. The configuration file contains the adjustment (deviation) data with following format.

    94  * <pre>

    95  *   StartYear/StartMonth(0-based)-EndYear/EndMonth(0-based):Deviation day (1, 2, -1, or -2)

    96  *   Line separator or ";" is used for the separator of each deviation data.</pre>

    97  *   Here is the example.

    98  * <pre>

    99  *     1429/0-1429/1:1

   100  *     1429/2-1429/7:1;1429/6-1429/11:1

   101  *     1429/11-9999/11:1</pre>

   102  * The default location of the configuration file is:

   103  * <pre>

   104  *   $CLASSPATH/java/time/i18n</pre>

   105  * And the default file name is:

   106  * <pre>

   107  *   hijrah_deviation.cfg</pre>

   108  * The default location and file name can be overriden by setting

   109  * following two Java's system property.

   110  * <pre>

   111  *   Location: java.time.i18n.HijrahDate.deviationConfigDir

   112  *   File name: java.time.i18n.HijrahDate.deviationConfigFile</pre>

   113  *

   114  * <h3>Specification for implementors</h3>

   115  * This class is immutable and thread-safe.

   116  *

   117  * @since 1.8

   118  */

   119 final class HijrahDate

   120         extends ChronoDateImpl<HijrahChrono>

   121         implements ChronoLocalDate<HijrahChrono>, Serializable {

   122     // this class is package-scoped so that future conversion to public

   123     // would not change serialization

   124 

   125     /**

   126      * Serialization version.

   127      */

   128     private static final long serialVersionUID = -5207853542612002020L;

   129 

   130     /**

   131      * The Chronology of this HijrahDate.

   132      */

   133     private final HijrahChrono chrono;

   134     /**

   135      * The era.

   136      */

   137     private final transient HijrahEra era;

   138     /**

   139      * The year.

   140      */

   141     private final transient int yearOfEra;

   142     /**

   143      * The month-of-year.

   144      */

   145     private final transient int monthOfYear;

   146     /**

   147      * The day-of-month.

   148      */

   149     private final transient int dayOfMonth;

   150     /**

   151      * The day-of-year.

   152      */

   153     private final transient int dayOfYear;

   154     /**

   155      * The day-of-week.

   156      */

   157     private final transient DayOfWeek dayOfWeek;

   158     /**

   159      * Gregorian days for this object. Holding number of days since 1970/01/01.

   160      * The number of days are calculated with pure Gregorian calendar

   161      * based.

   162      */

   163     private final long gregorianEpochDay;

   164     /**

   165      * True if year is leap year.

   166      */

   167     private final transient boolean isLeapYear;

   168 

   169     //-------------------------------------------------------------------------

   170     /**

   171      * Obtains an instance of {@code HijrahDate} from the Hijrah era year,

   172      * month-of-year and day-of-month. This uses the Hijrah era.

   173      *

   174      * @param prolepticYear  the proleptic year to represent in the Hijrah

   175      * @param monthOfYear  the month-of-year to represent, from 1 to 12

   176      * @param dayOfMonth  the day-of-month to represent, from 1 to 30

   177      * @return the Hijrah date, never null

   178      * @throws DateTimeException if the value of any field is out of range

   179      */

   180     static HijrahDate of(HijrahChrono chrono, int prolepticYear, int monthOfYear, int dayOfMonth) {

   181         return (prolepticYear >= 1) ?

   182             HijrahDate.of(chrono, HijrahEra.AH, prolepticYear, monthOfYear, dayOfMonth) :

   183             HijrahDate.of(chrono, HijrahEra.BEFORE_AH, 1 - prolepticYear, monthOfYear, dayOfMonth);

   184     }

   185 

   186     /**

   187      * Obtains an instance of {@code HijrahDate} from the era, year-of-era

   188      * month-of-year and day-of-month.

   189      *

   190      * @param era  the era to represent, not null

   191      * @param yearOfEra  the year-of-era to represent, from 1 to 9999

   192      * @param monthOfYear  the month-of-year to represent, from 1 to 12

   193      * @param dayOfMonth  the day-of-month to represent, from 1 to 31

   194      * @return the Hijrah date, never null

   195      * @throws DateTimeException if the value of any field is out of range

   196      */

   197     private static HijrahDate of(HijrahChrono chrono, HijrahEra era, int yearOfEra, int monthOfYear, int dayOfMonth) {

   198         Objects.requireNonNull(era, "era");

   199         chrono.checkValidYearOfEra(yearOfEra);

   200         chrono.checkValidMonth(monthOfYear);

   201         chrono.checkValidDayOfMonth(dayOfMonth);

   202         long gregorianDays = chrono.getGregorianEpochDay(era.prolepticYear(yearOfEra), monthOfYear, dayOfMonth);

   203         return new HijrahDate(chrono, gregorianDays);

   204     }

   205 

   206     /**

   207      * Obtains an instance of {@code HijrahDate} from a date.

   208      *

   209      * @param date  the date to use, not null

   210      * @return the Hijrah date, never null

   211      * @throws DateTimeException if the year is invalid

   212      */

   213     private static HijrahDate of(HijrahChrono chrono, LocalDate date) {

   214         long gregorianDays = date.toEpochDay();

   215         return new HijrahDate(chrono, gregorianDays);

   216     }

   217 

   218     static HijrahDate ofEpochDay(HijrahChrono chrono, long epochDay) {

   219         return new HijrahDate(chrono, epochDay);

   220     }

   221 

   222     /**

   223      * Constructs an instance with the specified date.

   224      *

   225      * @param gregorianDay  the number of days from 0001/01/01 (Gregorian), caller calculated

   226      */

   227     private HijrahDate(HijrahChrono chrono, long gregorianDay) {

   228         this.chrono = chrono;

   229         int[] dateInfo = chrono.getHijrahDateInfo(gregorianDay);

   230 

   231         chrono.checkValidYearOfEra(dateInfo[1]);

   232         chrono.checkValidMonth(dateInfo[2]);

   233         chrono.checkValidDayOfMonth(dateInfo[3]);

   234         chrono.checkValidDayOfYear(dateInfo[4]);

   235 

   236         this.era = HijrahEra.of(dateInfo[0]);

   237         this.yearOfEra = dateInfo[1];

   238         this.monthOfYear = dateInfo[2];

   239         this.dayOfMonth = dateInfo[3];

   240         this.dayOfYear = dateInfo[4];

   241         this.dayOfWeek = DayOfWeek.of(dateInfo[5]);

   242         this.gregorianEpochDay = gregorianDay;

   243         this.isLeapYear = chrono.isLeapYear(this.yearOfEra);

   244     }

   245 

   246     //-----------------------------------------------------------------------

   247     @Override

   248     public HijrahChrono getChrono() {

   249         return chrono;

   250     }

   251 

   252     @Override

   253     public ValueRange range(TemporalField field) {

   254         if (field instanceof ChronoField) {

   255             if (isSupported(field)) {

   256                 ChronoField f = (ChronoField) field;

   257                 switch (f) {

   258                     case DAY_OF_MONTH: return ValueRange.of(1, lengthOfMonth());

   259                     case DAY_OF_YEAR: return ValueRange.of(1, lengthOfYear());

   260                     case ALIGNED_WEEK_OF_MONTH: return ValueRange.of(1, 5);  // TODO

   261                     case YEAR_OF_ERA: return ValueRange.of(1, 1000);  // TODO

   262                 }

   263                 return getChrono().range(f);

   264             }

   265             throw new DateTimeException("Unsupported field: " + field.getName());

   266         }

   267         return field.doRange(this);

   268     }

   269 

   270     @Override

   271     public long getLong(TemporalField field) {

   272         if (field instanceof ChronoField) {

   273             switch ((ChronoField) field) {

   274                 case DAY_OF_WEEK: return dayOfWeek.getValue();

   275                 case ALIGNED_DAY_OF_WEEK_IN_MONTH: return ((dayOfWeek.getValue() - 1) % 7) + 1;

   276                 case ALIGNED_DAY_OF_WEEK_IN_YEAR: return ((dayOfYear - 1) % 7) + 1;

   277                 case DAY_OF_MONTH: return this.dayOfMonth;

   278                 case DAY_OF_YEAR: return this.dayOfYear;

   279                 case EPOCH_DAY: return toEpochDay();

   280                 case ALIGNED_WEEK_OF_MONTH: return ((dayOfMonth - 1) / 7) + 1;

   281                 case ALIGNED_WEEK_OF_YEAR: return ((dayOfYear - 1) / 7) + 1;

   282                 case MONTH_OF_YEAR: return monthOfYear;

   283                 case YEAR_OF_ERA: return yearOfEra;

   284                 case YEAR: return yearOfEra;

   285                 case ERA: return era.getValue();

   286             }

   287             throw new DateTimeException("Unsupported field: " + field.getName());

   288         }

   289         return field.doGet(this);

   290     }

   291 

   292     @Override

   293     public HijrahDate with(TemporalField field, long newValue) {

   294         if (field instanceof ChronoField) {

   295             ChronoField f = (ChronoField) field;

   296             f.checkValidValue(newValue);        // TODO: validate value

   297             int nvalue = (int) newValue;

   298             switch (f) {

   299                 case DAY_OF_WEEK: return plusDays(newValue - dayOfWeek.getValue());

   300                 case ALIGNED_DAY_OF_WEEK_IN_MONTH: return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_MONTH));

   301                 case ALIGNED_DAY_OF_WEEK_IN_YEAR: return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_YEAR));

   302                 case DAY_OF_MONTH: return resolvePreviousValid(yearOfEra, monthOfYear, nvalue);

   303                 case DAY_OF_YEAR: return resolvePreviousValid(yearOfEra, ((nvalue - 1) / 30) + 1, ((nvalue - 1) % 30) + 1);

   304                 case EPOCH_DAY: return new HijrahDate(chrono, nvalue);

   305                 case ALIGNED_WEEK_OF_MONTH: return plusDays((newValue - getLong(ALIGNED_WEEK_OF_MONTH)) * 7);

   306                 case ALIGNED_WEEK_OF_YEAR: return plusDays((newValue - getLong(ALIGNED_WEEK_OF_YEAR)) * 7);

   307                 case MONTH_OF_YEAR: return resolvePreviousValid(yearOfEra, nvalue, dayOfMonth);

   308                 case YEAR_OF_ERA: return resolvePreviousValid(yearOfEra >= 1 ? nvalue : 1 - nvalue, monthOfYear, dayOfMonth);

   309                 case YEAR: return resolvePreviousValid(nvalue, monthOfYear, dayOfMonth);

   310                 case ERA: return resolvePreviousValid(1 - yearOfEra, monthOfYear, dayOfMonth);

   311             }

   312             throw new DateTimeException("Unsupported field: " + field.getName());

   313         }

   314         return (HijrahDate) ChronoLocalDate.super.with(field, newValue);

   315     }

   316 

   317     private HijrahDate resolvePreviousValid(int yearOfEra, int month, int day) {

   318         int monthDays = getMonthDays(month - 1, yearOfEra);

   319         if (day > monthDays) {

   320             day = monthDays;

   321         }

   322         return HijrahDate.of(chrono, yearOfEra, month, day);

   323     }

   324 

   325     @Override

   326     public long toEpochDay() {

   327          return chrono.getGregorianEpochDay(yearOfEra, monthOfYear, dayOfMonth);

   328     }

   329 

   330     //-----------------------------------------------------------------------

   331     @Override

   332     public HijrahEra getEra() {

   333         return this.era;

   334     }

   335 

   336     //-----------------------------------------------------------------------

   337     /**

   338      * Checks if the year is a leap year, according to the Hijrah calendar system rules.

   339      *

   340      * @return true if this date is in a leap year

   341      */

   342     @Override

   343     public boolean isLeapYear() {

   344         return this.isLeapYear;

   345     }

   346 

   347     //-----------------------------------------------------------------------

   348     @Override

   349     public HijrahDate plusYears(long years) {

   350         if (years == 0) {

   351             return this;

   352         }

   353         int newYear = Math.addExact(this.yearOfEra, (int)years);

   354         return HijrahDate.of(chrono, this.era, newYear, this.monthOfYear, this.dayOfMonth);

   355     }

   356 

   357     @Override

   358     public HijrahDate plusMonths(long months) {

   359         if (months == 0) {

   360             return this;

   361         }

   362         int newMonth = this.monthOfYear - 1;

   363         newMonth = newMonth + (int)months;

   364         int years = newMonth / 12;

   365         newMonth = newMonth % 12;

   366         while (newMonth < 0) {

   367             newMonth += 12;

   368             years = Math.subtractExact(years, 1);

   369         }

   370         int newYear = Math.addExact(this.yearOfEra, years);

   371         return HijrahDate.of(chrono, this.era, newYear, newMonth + 1, this.dayOfMonth);

   372     }

   373 

   374     @Override

   375     public HijrahDate plusDays(long days) {

   376         return new HijrahDate(chrono, this.gregorianEpochDay + days);

   377     }

   378 

   379     /**

   380      * Returns month days from the beginning of year.

   381      *

   382      * @param month  month (0-based)

   383      * @parma year  year

   384      * @return month days from the beginning of year

   385      */

   386     private int getMonthDays(int month, int year) {

   387         int[] newMonths = chrono.getAdjustedMonthDays(year);

   388         return newMonths[month];

   389     }

   390 

   391     /**

   392      * Returns month length.

   393      *

   394      * @param month  month (0-based)

   395      * @param year  year

   396      * @return month length

   397      */

   398     private int getMonthLength(int month, int year) {

   399       int[] newMonths = chrono.getAdjustedMonthLength(year);

   400       return newMonths[month];

   401     }

   402 

   403     @Override

   404     public int lengthOfMonth() {

   405         return getMonthLength(monthOfYear - 1, yearOfEra);

   406     }

   407 

   408     @Override

   409     public int lengthOfYear() {

   410         return chrono.getYearLength(yearOfEra);  // TODO: proleptic year

   411     }

   412 

   413     //-----------------------------------------------------------------------

   414     private Object writeReplace() {

   415         return new Ser(Ser.HIJRAH_DATE_TYPE, this);

   416     }

   417 

   418     void writeExternal(ObjectOutput out) throws IOException {

   419         // HijrahChrono is implicit in the Hijrah_DATE_TYPE

   420         out.writeObject(chrono);

   421         out.writeInt(get(YEAR));

   422         out.writeByte(get(MONTH_OF_YEAR));

   423         out.writeByte(get(DAY_OF_MONTH));

   424     }

   425 

   426     /**

   427      * Replaces the date instance from the stream with a valid one.

   428      * ReadExternal has already read the fields and created a new instance

   429      * from the data.

   430      *

   431      * @return the resolved date, never null

   432      */

   433     private Object readResolve() {

   434         return this;

   435     }

   436 

   437     static ChronoLocalDate<HijrahChrono> readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

   438         HijrahChrono chrono = (HijrahChrono)in.readObject();

   439         int year = in.readInt();

   440         int month = in.readByte();

   441         int dayOfMonth = in.readByte();

   442         return chrono.date(year, month, dayOfMonth);

   443     }

   444 

   445 }