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 */ of(int year, int month, int dayOfMonth)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 */ LocalDate(int year, int month, int dayOfMonth)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 */ getYear()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 */ getMonth()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 */ getDayOfMonth()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 */ getDayOfWeek()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 */ plusDays(long daysToAdd)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 */ minusDays(long daysToSubtract)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 */ ofEpochDay(long epochDay)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 toEpochDay()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 */ compareTo(LocalDate otherDate)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 equals(Object obj)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 hashCode()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 } 364