implements ChronoPeriod, Serializable {

/**

public static final Period ZERO = new Period(0, 0, 0);

/**

@java.io.Serial

private static final long serialVersionUID = -3587258372562876L;

/**

private static final Pattern PATTERN =

Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?", Pattern.CASE_INSENSITIVE);

/**

private static final List<TemporalUnit> SUPPORTED_UNITS = List.of(YEARS, MONTHS, DAYS);

/**

private final int years;

/**

private final int months;

/**

private final int days;

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

/**

public static Period ofYears(int years) {

return create(years, 0, 0);

}

/**

public static Period ofMonths(int months) {

return create(0, months, 0);

}

/**

public static Period ofWeeks(int weeks) {

return create(0, 0, Math.multiplyExact(weeks, 7));

}

/**

public static Period ofDays(int days) {

return create(0, 0, days);

}

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

/**

public static Period of(int years, int months, int days) {

return create(years, months, days);

}

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

/**

public static Period from(TemporalAmount amount) {

if (amount instanceof Period) {

return (Period) amount;

}

if (amount instanceof ChronoPeriod) {

if (IsoChronology.INSTANCE.equals(((ChronoPeriod) amount).getChronology()) == false) {

throw new DateTimeException("Period requires ISO chronology: " + amount);

}

}

Objects.requireNonNull(amount, "amount");

int years = 0;

int months = 0;

int days = 0;

for (TemporalUnit unit : amount.getUnits()) {

long unitAmount = amount.get(unit);

if (unit == ChronoUnit.YEARS) {

years = Math.toIntExact(unitAmount);

} else if (unit == ChronoUnit.MONTHS) {

months = Math.toIntExact(unitAmount);

} else if (unit == ChronoUnit.DAYS) {

days = Math.toIntExact(unitAmount);

} else {

throw new DateTimeException("Unit must be Years, Months or Days, but was " + unit);

}

}

return create(years, months, days);

}

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

/**

public static Period parse(CharSequence text) {

Objects.requireNonNull(text, "text");

Matcher matcher = PATTERN.matcher(text);

if (matcher.matches()) {

int negate = (charMatch(text, matcher.start(1), matcher.end(1), '-') ? -1 : 1);

int yearStart = matcher.start(2), yearEnd = matcher.end(2);

int monthStart = matcher.start(3), monthEnd = matcher.end(3);

int weekStart = matcher.start(4), weekEnd = matcher.end(4);

int dayStart = matcher.start(5), dayEnd = matcher.end(5);

if (yearStart >= 0 || monthStart >= 0 || weekStart >= 0 || dayStart >= 0) {

try {

int years = parseNumber(text, yearStart, yearEnd, negate);

int months = parseNumber(text, monthStart, monthEnd, negate);

int weeks = parseNumber(text, weekStart, weekEnd, negate);

int days = parseNumber(text, dayStart, dayEnd, negate);

days = Math.addExact(days, Math.multiplyExact(weeks, 7));

return create(years, months, days);

} catch (NumberFormatException ex) {

throw new DateTimeParseException("Text cannot be parsed to a Period", text, 0, ex);

}

}

}

throw new DateTimeParseException("Text cannot be parsed to a Period", text, 0);

}

private static boolean charMatch(CharSequence text, int start, int end, char c) {

return (start >= 0 && end == start + 1 && text.charAt(start) == c);

}

private static int parseNumber(CharSequence text, int start, int end, int negate) {

if (start < 0 || end < 0) {

return 0;

}

int val = Integer.parseInt(text, start, end, 10);

try {

return Math.multiplyExact(val, negate);

} catch (ArithmeticException ex) {

throw new DateTimeParseException("Text cannot be parsed to a Period", text, 0, ex);

}

}

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

/**

public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive) {

return startDateInclusive.until(endDateExclusive);

}

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

/**

private static Period create(int years, int months, int days) {

if ((years | months | days) == 0) {

return ZERO;

}

return new Period(years, months, days);

}

/**

private Period(int years, int months, int days) {

this.years = years;

this.months = months;

this.days = days;

}

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

/**

@Override

public long get(TemporalUnit unit) {

if (unit == ChronoUnit.YEARS) {

return getYears();

} else if (unit == ChronoUnit.MONTHS) {

return getMonths();

} else if (unit == ChronoUnit.DAYS) {

return getDays();

} else {

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

}

}

/**

@Override

public List<TemporalUnit> getUnits() {

return SUPPORTED_UNITS;

}

/**

@Override

public IsoChronology getChronology() {

return IsoChronology.INSTANCE;

}

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

/**

public boolean isZero() {

return (this == ZERO);

}

/**

public boolean isNegative() {

return years < 0 || months < 0 || days < 0;

}

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

/**

public int getYears() {

return years;

}

/**

public int getMonths() {

return months;

}

/**

public int getDays() {

return days;

}

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

/**

public Period withYears(int years) {

if (years == this.years) {

return this;

}

return create(years, months, days);

}

/**

public Period withMonths(int months) {

if (months == this.months) {

return this;

}

return create(years, months, days);

}

/**

public Period withDays(int days) {

if (days == this.days) {

return this;

}

return create(years, months, days);

}

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

/**

public Period plus(TemporalAmount amountToAdd) {

Period isoAmount = Period.from(amountToAdd);

return create(

Math.addExact(years, isoAmount.years),

Math.addExact(months, isoAmount.months),

Math.addExact(days, isoAmount.days));

}

/**

public Period plusYears(long yearsToAdd) {

if (yearsToAdd == 0) {

return this;

}

return create(Math.toIntExact(Math.addExact(years, yearsToAdd)), months, days);

}

/**

public Period plusMonths(long monthsToAdd) {

if (monthsToAdd == 0) {

return this;

}

return create(years, Math.toIntExact(Math.addExact(months, monthsToAdd)), days);

}

/**

public Period plusDays(long daysToAdd) {

if (daysToAdd == 0) {

return this;

}

return create(years, months, Math.toIntExact(Math.addExact(days, daysToAdd)));

}

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

/**

public Period minus(TemporalAmount amountToSubtract) {

Period isoAmount = Period.from(amountToSubtract);

return create(

Math.subtractExact(years, isoAmount.years),

Math.subtractExact(months, isoAmount.months),

Math.subtractExact(days, isoAmount.days));

}

/**

public Period minusYears(long yearsToSubtract) {

return (yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-yearsToSubtract));

}

/**

public Period minusMonths(long monthsToSubtract) {

return (monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-monthsToSubtract));

}

/**

public Period minusDays(long daysToSubtract) {

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

}

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

/**

public Period multipliedBy(int scalar) {

if (this == ZERO || scalar == 1) {

return this;

}

return create(

Math.multiplyExact(years, scalar),

Math.multiplyExact(months, scalar),

Math.multiplyExact(days, scalar));

}

/**

public Period negated() {

return multipliedBy(-1);

}

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

/**

public Period normalized() {

long totalMonths = toTotalMonths();

long splitYears = totalMonths / 12;

int splitMonths = (int) (totalMonths % 12); // no overflow

if (splitYears == years && splitMonths == months) {

return this;

}

return create(Math.toIntExact(splitYears), splitMonths, days);

}

/**

public long toTotalMonths() {

return years * 12L + months; // no overflow

}

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

/**

@Override

public Temporal addTo(Temporal temporal) {

validateChrono(temporal);

if (months == 0) {

if (years != 0) {

temporal = temporal.plus(years, YEARS);

}

} else {

long totalMonths = toTotalMonths();

if (totalMonths != 0) {

temporal = temporal.plus(totalMonths, MONTHS);

}

}

if (days != 0) {

temporal = temporal.plus(days, DAYS);

}

return temporal;

}

/**

@Override

public Temporal subtractFrom(Temporal temporal) {

validateChrono(temporal);

if (months == 0) {

if (years != 0) {

temporal = temporal.minus(years, YEARS);

}

} else {

long totalMonths = toTotalMonths();

if (totalMonths != 0) {

temporal = temporal.minus(totalMonths, MONTHS);

}

}

if (days != 0) {

temporal = temporal.minus(days, DAYS);

}

return temporal;

}

/**

private void validateChrono(TemporalAccessor temporal) {

Objects.requireNonNull(temporal, "temporal");

Chronology temporalChrono = temporal.query(TemporalQueries.chronology());

if (temporalChrono != null && IsoChronology.INSTANCE.equals(temporalChrono) == false) {

throw new DateTimeException("Chronology mismatch, expected: ISO, actual: " + temporalChrono.getId());

}

}

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

/**

@Override

public boolean equals(Object obj) {

if (this == obj) {