implements Temporal, TemporalAdjuster, Comparable<YearMonth>, Serializable {

/**

@java.io.Serial

private static final long serialVersionUID = 4183400860270640070L;

/**

@java.io.Serial

private static final ObjectStreamField[] serialPersistentFields = {

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

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

};

/**

private static final DateTimeFormatter PARSER = new DateTimeFormatterBuilder()

.appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)

.appendLiteral('-')

.appendValue(MONTH_OF_YEAR, 2)

.toFormatter();

/**

private final transient int year;

/**

private final transient byte month;

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

/**

public static YearMonth now() {

return now(Clock.systemDefaultZone());

}

/**

public static YearMonth now(ZoneId zone) {

return now(Clock.system(zone));

}

/**

public static YearMonth now(Clock clock) {

final LocalDate now = LocalDate.now(clock); // called once

return YearMonth.of(now.getYear(), now.getMonth());

}

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

/**

public static YearMonth of(int year, Month month) {

Objects.requireNonNull(month, "month");

return of(year, month.getValue());

}

/**

public static YearMonth of(int year, int month) {

YEAR.checkValidValue(year);

MONTH_OF_YEAR.checkValidValue(month);

return new YearMonth(year, month);

}

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

/**

public static YearMonth from(TemporalAccessor temporal) {

if (temporal instanceof YearMonth) {

return (YearMonth) temporal;

}

Objects.requireNonNull(temporal, "temporal");

try {

if (IsoChronology.INSTANCE.equals(Chronology.from(temporal)) == false) {

temporal = LocalDate.from(temporal);

}

return of(temporal.get(YEAR), temporal.get(MONTH_OF_YEAR));

} catch (DateTimeException ex) {

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

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

}

}

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

/**

public static YearMonth parse(CharSequence text) {

return parse(text, PARSER);

}

/**

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

Objects.requireNonNull(formatter, "formatter");

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

}

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

/**

private YearMonth(int year, int month) {

this.year = year;

this.month = (byte) month;

}

/**

private YearMonth with(int newYear, int newMonth) {

if (year == newYear && month == newMonth) {

return this;

}

return new YearMonth(newYear, newMonth);

}

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

/**

@Override

public boolean isSupported(TemporalField field) {

if (field instanceof ChronoField) {

return field == YEAR || field == MONTH_OF_YEAR ||

field == PROLEPTIC_MONTH || field == YEAR_OF_ERA || field == ERA;

}

return field != null && field.isSupportedBy(this);

}

/**

@Override

public boolean isSupported(TemporalUnit unit) {

if (unit instanceof ChronoUnit) {

return unit == MONTHS || unit == YEARS || unit == DECADES || unit == CENTURIES || unit == MILLENNIA || unit == ERAS;

}

return unit != null && unit.isSupportedBy(this);

}

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

/**

@Override

public ValueRange range(TemporalField field) {

if (field == YEAR_OF_ERA) {

return (getYear() <= 0 ? ValueRange.of(1, Year.MAX_VALUE + 1) : ValueRange.of(1, Year.MAX_VALUE));

}

return Temporal.super.range(field);

}

/**

@Override // override for Javadoc

public int get(TemporalField field) {

return range(field).checkValidIntValue(getLong(field), field);

}

/**

@Override

public long getLong(TemporalField field) {

if (field instanceof ChronoField chronoField) {

return switch (chronoField) {

case MONTH_OF_YEAR -> month;

case PROLEPTIC_MONTH -> getProlepticMonth();

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

case YEAR -> year;

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

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

};

}

return field.getFrom(this);

}

private long getProlepticMonth() {

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

}

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

/**

public int getYear() {

return year;

}

/**

public int getMonthValue() {

return month;

}

/**

public Month getMonth() {

return Month.of(month);

}

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

/**

public boolean isLeapYear() {

return IsoChronology.INSTANCE.isLeapYear(year);

}

/**

public boolean isValidDay(int dayOfMonth) {

return dayOfMonth >= 1 && dayOfMonth <= lengthOfMonth();

}

/**

public int lengthOfMonth() {

return getMonth().length(isLeapYear());

}

/**

public int lengthOfYear() {

return (isLeapYear() ? 366 : 365);

}

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

/**

@Override

public YearMonth with(TemporalAdjuster adjuster) {

return (YearMonth) adjuster.adjustInto(this);

}

/**

@Override

public YearMonth with(TemporalField field, long newValue) {

if (field instanceof ChronoField chronoField) {

chronoField.checkValidValue(newValue);

return switch (chronoField) {

case MONTH_OF_YEAR -> withMonth((int) newValue);

case PROLEPTIC_MONTH -> plusMonths(newValue - getProlepticMonth());

case YEAR_OF_ERA -> withYear((int) (year < 1 ? 1 - newValue : newValue));

case YEAR -> withYear((int) newValue);

case ERA -> (getLong(ERA) == newValue ? this : withYear(1 - year));

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

};

}

return field.adjustInto(this, newValue);

}

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

/**

public YearMonth withYear(int year) {

YEAR.checkValidValue(year);

return with(year, month);

}

/**

public YearMonth withMonth(int month) {

MONTH_OF_YEAR.checkValidValue(month);

return with(year, month);

}

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

/**

@Override

public YearMonth plus(TemporalAmount amountToAdd) {

return (YearMonth) amountToAdd.addTo(this);

}

/**

@Override

public YearMonth plus(long amountToAdd, TemporalUnit unit) {

if (unit instanceof ChronoUnit chronoUnit) {

return switch (chronoUnit) {

case MONTHS -> plusMonths(amountToAdd);

case YEARS -> plusYears(amountToAdd);

case DECADES -> plusYears(Math.multiplyExact(amountToAdd, 10));

case CENTURIES -> plusYears(Math.multiplyExact(amountToAdd, 100));

case MILLENNIA -> plusYears(Math.multiplyExact(amountToAdd, 1000));

case ERAS -> with(ERA, Math.addExact(getLong(ERA), amountToAdd));

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

};

}

return unit.addTo(this, amountToAdd);

}

/**

public YearMonth plusYears(long yearsToAdd) {

if (yearsToAdd == 0) {

return this;

}

int newYear = YEAR.checkValidIntValue(year + yearsToAdd); // safe overflow

return with(newYear, month);

}

/**

public YearMonth plusMonths(long monthsToAdd) {

if (monthsToAdd == 0) {

return this;

}

long monthCount = year * 12L + (month - 1);

long calcMonths = monthCount + monthsToAdd; // safe overflow

int newYear = YEAR.checkValidIntValue(Math.floorDiv(calcMonths, 12));

int newMonth = Math.floorMod(calcMonths, 12) + 1;

return with(newYear, newMonth);

}

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

/**

@Override

public YearMonth minus(TemporalAmount amountToSubtract) {

return (YearMonth) amountToSubtract.subtractFrom(this);

}

/**

@Override

public YearMonth minus(long amountToSubtract, TemporalUnit unit) {

return (amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit) : plus(-amountToSubtract, unit));

}

/**

public YearMonth minusYears(long yearsToSubtract) {

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

}

/**

public YearMonth minusMonths(long monthsToSubtract) {

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

}

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

/**

@SuppressWarnings("unchecked")

@Override

public <R> R query(TemporalQuery<R> query) {

if (query == TemporalQueries.chronology()) {

return (R) IsoChronology.INSTANCE;

} else if (query == TemporalQueries.precision()) {

return (R) MONTHS;

}

return Temporal.super.query(query);

}

/**