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  * This file is available under and governed by the GNU General Public

    28  * License version 2 only, as published by the Free Software Foundation.

    29  * However, the following notice accompanied the original version of this

    30  * file:

    31  *

    32  * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos

    33  *

    34  * All rights reserved.

    35  *

    36  * Redistribution and use in source and binary forms, with or without

    37  * modification, are permitted provided that the following conditions are met:

    38  *

    39  *  * Redistributions of source code must retain the above copyright notice,

    40  *    this list of conditions and the following disclaimer.

    41  *

    42  *  * Redistributions in binary form must reproduce the above copyright notice,

    43  *    this list of conditions and the following disclaimer in the documentation

    44  *    and/or other materials provided with the distribution.

    45  *

    46  *  * Neither the name of JSR-310 nor the names of its contributors

    47  *    may be used to endorse or promote products derived from this software

    48  *    without specific prior written permission.

    49  *

    50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    54  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    55  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    56  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    57  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    58  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    59  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    60  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    61  */

    62 package build.tools.tzdb;

    63 

    64 import static build.tools.tzdb.Utils.*;

    65 import static build.tools.tzdb.LocalTime.SECONDS_PER_DAY;

    66 import static build.tools.tzdb.ChronoField.DAY_OF_MONTH;

    67 import static build.tools.tzdb.ChronoField.MONTH_OF_YEAR;

    68 import static build.tools.tzdb.ChronoField.YEAR;

    69 

    70 import java.util.Objects;

    71 

    72 /**

    73  * A date without a time-zone in the ISO-8601 calendar system,

    74  * such as {@code 2007-12-03}.

    75  *

    76  * @since 1.8

    77  */

    78 final class LocalDate {

    79 

    80     /**

    81      * The minimum supported {@code LocalDate}, '-999999999-01-01'.

    82      * This could be used by an application as a "far past" date.

    83      */

    84     public static final LocalDate MIN = new LocalDate(YEAR_MIN_VALUE, 1, 1);

    85     /**

    86      * The maximum supported {@code LocalDate}, '+999999999-12-31'.

    87      * This could be used by an application as a "far future" date.

    88      */

    89     public static final LocalDate MAX = new LocalDate(YEAR_MAX_VALUE, 12, 31);

    90 

    91     /**

    92      * The number of days in a 400 year cycle.

    93      */

    94     private static final int DAYS_PER_CYCLE = 146097;

    95     /**

    96      * The number of days from year zero to year 1970.

    97      * There are five 400 year cycles from year zero to 2000.

    98      * There are 7 leap years from 1970 to 2000.

    99      */

   100     static final long DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5L) - (30L * 365L + 7L);

   101 

   102     /**

   103      * The year.

   104      */

   105     private final int year;

   106     /**

   107      * The month-of-year.

   108      */

   109     private final short month;

   110     /**

   111      * The day-of-month.

   112      */

   113     private final short day;

   114 

   115     /**

   116      * Obtains an instance of {@code LocalDate} from a year, month and day.

   117      * <p>

   118      * The day must be valid for the year and month, otherwise an exception will be thrown.

   119      *

   120      * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

   121      * @param month  the month-of-year to represent, from 1 (January) to 12 (December)

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

   123      * @return the local date, not null

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

   125      * @throws DateTimeException if the day-of-month is invalid for the month-year

   126      */

   127     public static LocalDate of(int year, int month, int dayOfMonth) {

   128         YEAR.checkValidValue(year);

   129         MONTH_OF_YEAR.checkValidValue(month);

   130         DAY_OF_MONTH.checkValidValue(dayOfMonth);

   131         if (dayOfMonth > 28 && dayOfMonth > lengthOfMonth(month, isLeapYear(year))) {

   132             if (dayOfMonth == 29) {

   133                 throw new DateTimeException("Invalid date 'February 29' as '" + year + "' is not a leap year");

   134             } else {

   135                 throw new DateTimeException("Invalid date '" + month + " " + dayOfMonth + "'");

   136             }

   137         }

   138         return new LocalDate(year, month, dayOfMonth);

   139     }

   140 

   141     /**

   142      * Constructor, previously validated.

   143      *

   144      * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

   145      * @param month  the month-of-year to represent, not null

   146      * @param dayOfMonth  the day-of-month to represent, valid for year-month, from 1 to 31

   147      */

   148     private LocalDate(int year, int month, int dayOfMonth) {

   149         this.year = year;

   150         this.month = (short) month;

   151         this.day = (short) dayOfMonth;

   152     }

   153 

   154     /**

   155      * Gets the year field.

   156      * <p>

   157      * This method returns the primitive {@code int} value for the year.

   158      * <p>

   159      * The year returned by this method is proleptic as per {@code get(YEAR)}.

   160      * To obtain the year-of-era, use {@code get(YEAR_OF_ERA}.

   161      *

   162      * @return the year, from MIN_YEAR to MAX_YEAR

   163      */

   164     public int getYear() {

   165         return year;

   166     }

   167 

   168     /**

   169      * Gets the month-of-year field as an int from 1 to 12.

   170      *

   171      * @return the month-of-year

   172      */

   173     public int getMonth() {

   174         return month;

   175     }

   176 

   177     /**

   178      * Gets the day-of-month field.

   179      * <p>

   180      * This method returns the primitive {@code int} value for the day-of-month.

   181      *

   182      * @return the day-of-month, from 1 to 31

   183      */

   184     public int getDayOfMonth() {

   185         return day;

   186     }

   187 

   188     /**

   189      * Gets the day-of-week field, which is an int from 1 to 7.

   190      *

   191      * @return the day-of-week

   192      */

   193     public int getDayOfWeek() {

   194         return (int)floorMod(toEpochDay() + 3, 7) + 1;

   195     }

   196 

   197     /**

   198      * Returns a copy of this {@code LocalDate} with the specified number of days added.

   199      * <p>

   200      * This method adds the specified amount to the days field incrementing the

   201      * month and year fields as necessary to ensure the result remains valid.

   202      * The result is only invalid if the maximum/minimum year is exceeded.

   203      * <p>

   204      * For example, 2008-12-31 plus one day would result in 2009-01-01.

   205      * <p>

   206      * This instance is immutable and unaffected by this method call.

   207      *

   208      * @param daysToAdd  the days to add, may be negative

   209      * @return a {@code LocalDate} based on this date with the days added, not null

   210      * @throws DateTimeException if the result exceeds the supported date range

   211      */

   212     public LocalDate plusDays(long daysToAdd) {

   213         if (daysToAdd == 0) {

   214             return this;

   215         }

   216         long mjDay = addExact(toEpochDay(), daysToAdd);

   217         return LocalDate.ofEpochDay(mjDay);

   218     }

   219 

   220     /**

   221      * Returns a copy of this {@code LocalDate} with the specified number of days subtracted.

   222      * <p>

   223      * This method subtracts the specified amount from the days field decrementing the

   224      * month and year fields as necessary to ensure the result remains valid.

   225      * The result is only invalid if the maximum/minimum year is exceeded.

   226      * <p>

   227      * For example, 2009-01-01 minus one day would result in 2008-12-31.

   228      * <p>

   229      * This instance is immutable and unaffected by this method call.

   230      *

   231      * @param daysToSubtract  the days to subtract, may be negative

   232      * @return a {@code LocalDate} based on this date with the days subtracted, not null

   233      * @throws DateTimeException if the result exceeds the supported date range

   234      */

   235     public LocalDate minusDays(long daysToSubtract) {

   236         return (daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract));

   237     }

   238 

   239     /**

   240      * Obtains an instance of {@code LocalDate} from the epoch day count.

   241      * <p>

   242      * The Epoch Day count is a simple incrementing count of days

   243      * where day 0 is 1970-01-01. Negative numbers represent earlier days.

   244      *

   245      * @param epochDay  the Epoch Day to convert, based on the epoch 1970-01-01

   246      * @return the local date, not null

   247      * @throws DateTimeException if the epoch days exceeds the supported date range

   248      */

   249     public static LocalDate ofEpochDay(long epochDay) {

   250         long zeroDay = epochDay + DAYS_0000_TO_1970;

   251         // find the march-based year

   252         zeroDay -= 60;  // adjust to 0000-03-01 so leap day is at end of four year cycle

   253         long adjust = 0;

   254         if (zeroDay < 0) {

   255             // adjust negative years to positive for calculation

   256             long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1;

   257             adjust = adjustCycles * 400;

   258             zeroDay += -adjustCycles * DAYS_PER_CYCLE;

   259         }

   260         long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE;

   261         long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);

   262         if (doyEst < 0) {

   263             // fix estimate

   264             yearEst--;

   265             doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);

   266         }

   267         yearEst += adjust;  // reset any negative year

   268         int marchDoy0 = (int) doyEst;

   269 

   270         // convert march-based values back to january-based

   271         int marchMonth0 = (marchDoy0 * 5 + 2) / 153;

   272         int month = (marchMonth0 + 2) % 12 + 1;

   273         int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;

   274         yearEst += marchMonth0 / 10;

   275 

   276         // check year now we are certain it is correct

   277         int year = YEAR.checkValidValue((int)yearEst);

   278         return new LocalDate(year, month, dom);

   279     }

   280 

   281     public long toEpochDay() {

   282         long y = year;

   283         long m = month;

   284         long total = 0;

   285         total += 365 * y;

   286         if (y >= 0) {

   287             total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;

   288         } else {

   289             total -= y / -4 - y / -100 + y / -400;

   290         }

   291         total += ((367 * m - 362) / 12);

   292         total += day - 1;

   293         if (m > 2) {

   294             total--;

   295             if (isLeapYear(year) == false) {

   296                 total--;

   297             }

   298         }

   299         return total - DAYS_0000_TO_1970;

   300     }

   301 

   302     /**

   303      * Compares this date to another date.

   304      * <p>

   305      * The comparison is primarily based on the date, from earliest to latest.

   306      * It is "consistent with equals", as defined by {@link Comparable}.

   307      * <p>

   308      * If all the dates being compared are instances of {@code LocalDate},

   309      * then the comparison will be entirely based on the date.

   310      * If some dates being compared are in different chronologies, then the

   311      * chronology is also considered, see {@link java.time.temporal.ChronoLocalDate#compareTo}.

   312      *

   313      * @param other  the other date to compare to, not null

   314      * @return the comparator value, negative if less, positive if greater

   315      */

   316     public int compareTo(LocalDate otherDate) {

   317         int cmp = (year - otherDate.year);

   318         if (cmp == 0) {

   319             cmp = (month - otherDate.month);

   320             if (cmp == 0) {

   321                 cmp = (day - otherDate.day);

   322             }

   323         }

   324         return cmp;

   325     }

   326 

   327     /**

   328      * Checks if this date is equal to another date.

   329      * <p>

   330      * Compares this {@code LocalDate} with another ensuring that the date is the same.

   331      * <p>

   332      * Only objects of type {@code LocalDate} are compared, other types return false.

   333      * To compare the dates of two {@code TemporalAccessor} instances, including dates

   334      * in two different chronologies, use {@link ChronoField#EPOCH_DAY} as a comparator.

   335      *

   336      * @param obj  the object to check, null returns false

   337      * @return true if this is equal to the other date

   338      */

   339     @Override

   340     public boolean equals(Object obj) {

   341         if (this == obj) {

   342             return true;

   343         }

   344         if (obj instanceof LocalDate) {

   345             return compareTo((LocalDate) obj) == 0;

   346         }

   347         return false;

   348     }

   349 

   350     /**

   351      * A hash code for this date.

   352      *

   353      * @return a suitable hash code

   354      */

   355     @Override

   356     public int hashCode() {

   357         int yearValue = year;

   358         int monthValue = month;

   359         int dayValue = day;

   360         return (yearValue & 0xFFFFF800) ^ ((yearValue << 11) + (monthValue << 6) + (dayValue));

   361     }

   362 

   363 }