implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {

/**

@Serial

private static final ObjectStreamField[] serialPersistentFields = {

new ObjectStreamField("year", int.class),

new ObjectStreamField("month", short.class),

new ObjectStreamField("day", short.class)

};

/**

public static final LocalDate MIN = LocalDate.of(Year.MIN_VALUE, 1, 1);

/**

public static final LocalDate MAX = LocalDate.of(Year.MAX_VALUE, 12, 31);

/**

public static final LocalDate EPOCH = LocalDate.of(1970, 1, 1);

/**

@java.io.Serial

private static final long serialVersionUID = 2942565459149668126L;

/**

private static final int DAYS_PER_CYCLE = 146097;

/**

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

/**

private final transient int year;

/**

private final transient byte month;

/**

private final transient byte day;

//-----------------------------------------------------------------------

/**

public static LocalDate now() {

return now(Clock.systemDefaultZone());

}

/**

public static LocalDate now(ZoneId zone) {

return now(Clock.system(zone));

}

/**

public static LocalDate now(Clock clock) {

Objects.requireNonNull(clock, "clock");

final Instant now = clock.instant(); // called once

return ofInstant(now, clock.getZone());

}

//-----------------------------------------------------------------------

/**

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

YEAR.checkValidValue(year);

Objects.requireNonNull(month, "month");

DAY_OF_MONTH.checkValidValue(dayOfMonth);

return create(year, month.getValue(), dayOfMonth);

}

/**

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

YEAR.checkValidValue(year);

MONTH_OF_YEAR.checkValidValue(month);

DAY_OF_MONTH.checkValidValue(dayOfMonth);

return create(year, month, dayOfMonth);

}

//-----------------------------------------------------------------------

/**

public static LocalDate ofYearDay(int year, int dayOfYear) {

YEAR.checkValidValue(year);

DAY_OF_YEAR.checkValidValue(dayOfYear);

boolean leap = IsoChronology.INSTANCE.isLeapYear(year);

if (dayOfYear == 366 && leap == false) {

throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");

}

Month moy = Month.of((dayOfYear - 1) / 31 + 1);

int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;

if (dayOfYear > monthEnd) {

moy = moy.plus(1);

}

int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;

return new LocalDate(year, moy.getValue(), dom);

}

//-----------------------------------------------------------------------

/**

public static LocalDate ofInstant(Instant instant, ZoneId zone) {

Objects.requireNonNull(instant, "instant");

Objects.requireNonNull(zone, "zone");

ZoneRules rules = zone.getRules();

ZoneOffset offset = rules.getOffset(instant);

long localSecond = instant.getEpochSecond() + offset.getTotalSeconds();

long localEpochDay = Math.floorDiv(localSecond, SECONDS_PER_DAY);

return ofEpochDay(localEpochDay);

}

//-----------------------------------------------------------------------

/**

public static LocalDate ofEpochDay(long epochDay) {

EPOCH_DAY.checkValidValue(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 + 3;

if (month > 12) {

month -= 12;

}

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

if (marchDoy0 >= 306) {

yearEst++;

}

return new LocalDate((int)yearEst, month, dom);

}

//-----------------------------------------------------------------------

/**

public static LocalDate from(TemporalAccessor temporal) {

Objects.requireNonNull(temporal, "temporal");

LocalDate date = temporal.query(TemporalQueries.localDate());

if (date == null) {

throw new DateTimeException("Unable to obtain LocalDate from TemporalAccessor: " +

temporal + " of type " + temporal.getClass().getName());

}

return date;

}

//-----------------------------------------------------------------------

/**

public static LocalDate parse(CharSequence text) {

return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);

}

/**

public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {

Objects.requireNonNull(formatter, "formatter");

return formatter.parse(text, LocalDate::from);

}

//-----------------------------------------------------------------------

/**

private static LocalDate create(int year, int month, int dayOfMonth) {

if (dayOfMonth > 28) {

int dom = switch (month) {

case 2 -> (IsoChronology.INSTANCE.isLeapYear(year) ? 29 : 28);

case 4, 6, 9, 11 -> 30;

default -> 31;

};

if (dayOfMonth > dom) {

if (dayOfMonth == 29) {

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

} else {

throw new DateTimeException("Invalid date '" + Month.of(month).name() + " " + dayOfMonth + "'");

}

}

}

return new LocalDate(year, month, dayOfMonth);

}

/**

private static LocalDate resolvePreviousValid(int year, int month, int day) {

switch (month) {

case 2 -> day = Math.min(day, IsoChronology.INSTANCE.isLeapYear(year) ? 29 : 28);

case 4, 6, 9, 11 -> day = Math.min(day, 30);

}

return new LocalDate(year, month, day);

}

/**

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

this.year = year;

this.month = (byte) month;

this.day = (byte) dayOfMonth;

}

//-----------------------------------------------------------------------

/**

@Override // override for Javadoc

public boolean isSupported(TemporalField field) {

return ChronoLocalDate.super.isSupported(field);

}

/**

@Override // override for Javadoc

public boolean isSupported(TemporalUnit unit) {

return ChronoLocalDate.super.isSupported(unit);

}

//-----------------------------------------------------------------------

/**

@Override

public ValueRange range(TemporalField field) {

if (field instanceof ChronoField chronoField) {

if (chronoField.isDateBased()) {

return switch (chronoField) {

case DAY_OF_MONTH -> ValueRange.of(1, lengthOfMonth());

case DAY_OF_YEAR -> ValueRange.of(1, lengthOfYear());

case ALIGNED_WEEK_OF_MONTH -> ValueRange.of(1, getMonth() == Month.FEBRUARY && !isLeapYear() ? 4 : 5);

case YEAR_OF_ERA -> (getYear() <= 0 ? ValueRange.of(1, Year.MAX_VALUE + 1) : ValueRange.of(1, Year.MAX_VALUE));

default -> field.range();

};

}

throw new UnsupportedTemporalTypeException("Unsupported field: " + field);

}

return field.rangeRefinedBy(this);

}

/**

@Override // override for Javadoc and performance

public int get(TemporalField field) {

if (field instanceof ChronoField) {

return get0(field);

}

return ChronoLocalDate.super.get(field);

}

/**

@Override

public long getLong(TemporalField field) {

if (field instanceof ChronoField) {

if (field == EPOCH_DAY) {

return toEpochDay();

}

if (field == PROLEPTIC_MONTH) {

return getProlepticMonth();

}

return get0(field);

}

return field.getFrom(this);

}

private int get0(TemporalField field) {

return switch ((ChronoField) field) {

case DAY_OF_WEEK -> getDayOfWeek().getValue();

case ALIGNED_DAY_OF_WEEK_IN_MONTH -> ((day - 1) % 7) + 1;

case ALIGNED_DAY_OF_WEEK_IN_YEAR -> ((getDayOfYear() - 1) % 7) + 1;

case DAY_OF_MONTH -> day;

case DAY_OF_YEAR -> getDayOfYear();

case EPOCH_DAY -> throw new UnsupportedTemporalTypeException("Invalid field 'EpochDay' for get() method, use getLong() instead");

case ALIGNED_WEEK_OF_MONTH -> ((day - 1) / 7) + 1;

case ALIGNED_WEEK_OF_YEAR -> ((getDayOfYear() - 1) / 7) + 1;

case MONTH_OF_YEAR -> month;

case PROLEPTIC_MONTH -> throw new UnsupportedTemporalTypeException("Invalid field 'ProlepticMonth' for get() method, use getLong() instead");

case YEAR_OF_ERA -> (year >= 1 ? year : 1 - year);

case YEAR -> year;

case ERA -> (year >= 1 ? 1 : 0);

default -> throw new UnsupportedTemporalTypeException("Unsupported field: " + field);

};

}

private long getProlepticMonth() {

return (year * 12L + month - 1);

}

//-----------------------------------------------------------------------

/**

@Override

public IsoChronology getChronology() {

return IsoChronology.INSTANCE;

}

/**

@Override // override for Javadoc

public IsoEra getEra() {

return (getYear() >= 1 ? IsoEra.CE : IsoEra.BCE);

}

/**

public int getYear() {

return year;

}

/**

public int getMonthValue() {

return month;

}

/**

public Month getMonth() {

return Month.of(month);

}

/**

public int getDayOfMonth() {

return day;

}

/**

public int getDayOfYear() {

return getMonth().firstDayOfYear(isLeapYear()) + day - 1;

}

/**

public DayOfWeek getDayOfWeek() {

int dow0 = Math.floorMod(toEpochDay() + 3, 7);

return DayOfWeek.of(dow0 + 1);

}

//-----------------------------------------------------------------------

/**

@Override // override for Javadoc and performance

public boolean isLeapYear() {

return IsoChronology.INSTANCE.isLeapYear(year);

}

/**

@Override

public int lengthOfMonth() {

return switch (month) {

case 2 -> (isLeapYear() ? 29 : 28);

case 4, 6, 9, 11 -> 30;

default -> 31;

};

}

/**

@Override // override for Javadoc and performance

public int lengthOfYear() {

return (isLeapYear() ? 366 : 365);

}

//-----------------------------------------------------------------------

/**

@Override

public LocalDate with(TemporalAdjuster adjuster) {

// optimizations

if (adjuster instanceof LocalDate) {

return (LocalDate) adjuster;

}

return (LocalDate) adjuster.adjustInto(this);

}

/**