+ * The day must be valid for the year and month, otherwise an exception will be thrown. + * + * @param year the year to represent, from MIN_YEAR to MAX_YEAR + * @param month the month-of-year to represent, from 1 (January) to 12 (December) + * @param dayOfMonth the day-of-month to represent, from 1 to 31 + * @return the local date, not null + * @throws DateTimeException if the value of any field is out of range + * @throws DateTimeException if the day-of-month is invalid for the month-year + */ + public static LocalDate of(int year, int month, int dayOfMonth) { + YEAR.checkValidValue(year); + MONTH_OF_YEAR.checkValidValue(month); + DAY_OF_MONTH.checkValidValue(dayOfMonth); + if (dayOfMonth > 28 && dayOfMonth > lengthOfMonth(month, isLeapYear(year))) { + if (dayOfMonth == 29) { + throw new DateTimeException("Invalid date 'February 29' as '" + year + "' is not a leap year"); + } else { + throw new DateTimeException("Invalid date '" + month + " " + dayOfMonth + "'"); + } + } + return new LocalDate(year, month, dayOfMonth); + } + + /** + * Constructor, previously validated. + * + * @param year the year to represent, from MIN_YEAR to MAX_YEAR + * @param month the month-of-year to represent, not null + * @param dayOfMonth the day-of-month to represent, valid for year-month, from 1 to 31 + */ + private LocalDate(int year, int month, int dayOfMonth) { + this.year = year; + this.month = (short) month; + this.day = (short) dayOfMonth; + } + + /** + * Gets the year field. + *
+ * This method returns the primitive {@code int} value for the year. + *
+ * The year returned by this method is proleptic as per {@code get(YEAR)}. + * To obtain the year-of-era, use {@code get(YEAR_OF_ERA}. + * + * @return the year, from MIN_YEAR to MAX_YEAR + */ + public int getYear() { + return year; + } + + /** + * Gets the month-of-year field as an int from 1 to 12. + * + * @return the month-of-year + */ + public int getMonth() { + return month; + } + + /** + * Gets the day-of-month field. + *
+ * This method returns the primitive {@code int} value for the day-of-month. + * + * @return the day-of-month, from 1 to 31 + */ + public int getDayOfMonth() { + return day; + } + + /** + * Gets the day-of-week field, which is an int from 1 to 7. + * + * @return the day-of-week + */ + public int getDayOfWeek() { + return (int)floorMod(toEpochDay() + 3, 7) + 1; + } + + /** + * Returns a copy of this {@code LocalDate} with the specified number of days added. + *
+ * This method adds the specified amount to the days field incrementing the + * month and year fields as necessary to ensure the result remains valid. + * The result is only invalid if the maximum/minimum year is exceeded. + *
+ * For example, 2008-12-31 plus one day would result in 2009-01-01. + *
+ * This instance is immutable and unaffected by this method call. + * + * @param daysToAdd the days to add, may be negative + * @return a {@code LocalDate} based on this date with the days added, not null + * @throws DateTimeException if the result exceeds the supported date range + */ + public LocalDate plusDays(long daysToAdd) { + if (daysToAdd == 0) { + return this; + } + long mjDay = addExact(toEpochDay(), daysToAdd); + return LocalDate.ofEpochDay(mjDay); + } + + /** + * Returns a copy of this {@code LocalDate} with the specified number of days subtracted. + *
+ * This method subtracts the specified amount from the days field decrementing the + * month and year fields as necessary to ensure the result remains valid. + * The result is only invalid if the maximum/minimum year is exceeded. + *
+ * For example, 2009-01-01 minus one day would result in 2008-12-31. + *
+ * This instance is immutable and unaffected by this method call. + * + * @param daysToSubtract the days to subtract, may be negative + * @return a {@code LocalDate} based on this date with the days subtracted, not null + * @throws DateTimeException if the result exceeds the supported date range + */ + public LocalDate minusDays(long daysToSubtract) { + return (daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract)); + } + + /** + * Obtains an instance of {@code LocalDate} from the epoch day count. + *
+ * The Epoch Day count is a simple incrementing count of days + * where day 0 is 1970-01-01. Negative numbers represent earlier days. + * + * @param epochDay the Epoch Day to convert, based on the epoch 1970-01-01 + * @return the local date, not null + * @throws DateTimeException if the epoch days exceeds the supported date range + */ + public static LocalDate ofEpochDay(long epochDay) { + long zeroDay = epochDay + DAYS_0000_TO_1970; + // find the march-based year + zeroDay -= 60; // adjust to 0000-03-01 so leap day is at end of four year cycle + long adjust = 0; + if (zeroDay < 0) { + // adjust negative years to positive for calculation + long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1; + adjust = adjustCycles * 400; + zeroDay += -adjustCycles * DAYS_PER_CYCLE; + } + long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE; + long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400); + if (doyEst < 0) { + // fix estimate + yearEst--; + doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400); + } + yearEst += adjust; // reset any negative year + int marchDoy0 = (int) doyEst; + + // convert march-based values back to january-based + int marchMonth0 = (marchDoy0 * 5 + 2) / 153; + int month = (marchMonth0 + 2) % 12 + 1; + int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1; + yearEst += marchMonth0 / 10; + + // check year now we are certain it is correct + int year = YEAR.checkValidValue((int)yearEst); + return new LocalDate(year, month, dom); + } + + public long toEpochDay() { + long y = year; + long m = month; + long total = 0; + total += 365 * y; + if (y >= 0) { + total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400; + } else { + total -= y / -4 - y / -100 + y / -400; + } + total += ((367 * m - 362) / 12); + total += day - 1; + if (m > 2) { + total--; + if (isLeapYear(year) == false) { + total--; + } + } + return total - DAYS_0000_TO_1970; + } + + /** + * Compares this date to another date. + *
+ * The comparison is primarily based on the date, from earliest to latest. + * It is "consistent with equals", as defined by {@link Comparable}. + *
+ * If all the dates being compared are instances of {@code LocalDate}, + * then the comparison will be entirely based on the date. + * If some dates being compared are in different chronologies, then the + * chronology is also considered, see {@link java.time.temporal.ChronoLocalDate#compareTo}. + * + * @param other the other date to compare to, not null + * @return the comparator value, negative if less, positive if greater + */ + public int compareTo(LocalDate otherDate) { + int cmp = (year - otherDate.year); + if (cmp == 0) { + cmp = (month - otherDate.month); + if (cmp == 0) { + cmp = (day - otherDate.day); + } + } + return cmp; + } + + /** + * Checks if this date is equal to another date. + *
+ * Compares this {@code LocalDate} with another ensuring that the date is the same. + *
+ * Only objects of type {@code LocalDate} are compared, other types return false. + * To compare the dates of two {@code TemporalAccessor} instances, including dates + * in two different chronologies, use {@link ChronoField#EPOCH_DAY} as a comparator. + * + * @param obj the object to check, null returns false + * @return true if this is equal to the other date + */ + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LocalDate) { + return compareTo((LocalDate) obj) == 0; + } + return false; + } + + /** + * A hash code for this date. + * + * @return a suitable hash code + */ + @Override + public int hashCode() { + int yearValue = year; + int monthValue = month; + int dayValue = day; + return (yearValue & 0xFFFFF800) ^ ((yearValue << 11) + (monthValue << 6) + (dayValue)); + } + +}