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

/**

public static final Instant EPOCH = new Instant(0, 0);

/**

private static final long MIN_SECOND = -31557014167219200L;

/**

private static final long MAX_SECOND = 31556889864403199L;

/**

public static final Instant MIN = Instant.ofEpochSecond(MIN_SECOND, 0);

/**

public static final Instant MAX = Instant.ofEpochSecond(MAX_SECOND, 999_999_999);

/**

@java.io.Serial

private static final long serialVersionUID = -665713676816604388L;

/**

private final long seconds;

/**

private final int nanos;

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

/**

public static Instant now() {

return Clock.currentInstant();

}

/**

public static Instant now(Clock clock) {

Objects.requireNonNull(clock, "clock");

return clock.instant();

}

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

/**

public static Instant ofEpochSecond(long epochSecond) {

return create(epochSecond, 0);

}

/**

public static Instant ofEpochSecond(long epochSecond, long nanoAdjustment) {

long secs = Math.addExact(epochSecond, Math.floorDiv(nanoAdjustment, NANOS_PER_SECOND));

int nos = (int)Math.floorMod(nanoAdjustment, NANOS_PER_SECOND);

return create(secs, nos);

}

/**

public static Instant ofEpochMilli(long epochMilli) {

long secs = Math.floorDiv(epochMilli, 1000);

int mos = Math.floorMod(epochMilli, 1000);

return create(secs, mos * 1000_000);

}

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

/**

public static Instant from(TemporalAccessor temporal) {

if (temporal instanceof Instant) {

return (Instant) temporal;

}

Objects.requireNonNull(temporal, "temporal");

try {

long instantSecs = temporal.getLong(INSTANT_SECONDS);

int nanoOfSecond = temporal.get(NANO_OF_SECOND);

return Instant.ofEpochSecond(instantSecs, nanoOfSecond);

} catch (DateTimeException ex) {

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

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

}

}

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

/**

public static Instant parse(final CharSequence text) {

return DateTimeFormatter.ISO_INSTANT.parse(text, Instant::from);

}

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

/**

private static Instant create(long seconds, int nanoOfSecond) {

if ((seconds | nanoOfSecond) == 0) {

return EPOCH;

}

if (seconds < MIN_SECOND || seconds > MAX_SECOND) {

throw new DateTimeException("Instant exceeds minimum or maximum instant");

}

return new Instant(seconds, nanoOfSecond);

}

/**

private Instant(long epochSecond, int nanos) {

this.seconds = epochSecond;

this.nanos = nanos;

}

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

/**

@Override

public boolean isSupported(TemporalField field) {

if (field instanceof ChronoField) {

return field == INSTANT_SECONDS || field == NANO_OF_SECOND || field == MICRO_OF_SECOND || field == MILLI_OF_SECOND;

}

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

}

/**

@Override

public boolean isSupported(TemporalUnit unit) {

if (unit instanceof ChronoUnit) {

return unit.isTimeBased() || unit == DAYS;

}

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

}

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

/**

@Override // override for Javadoc

public ValueRange range(TemporalField field) {

return Temporal.super.range(field);

}

/**

@Override // override for Javadoc and performance

public int get(TemporalField field) {

if (field instanceof ChronoField chronoField) {

return switch (chronoField) {

case NANO_OF_SECOND -> nanos;

case MICRO_OF_SECOND -> nanos / 1000;

case MILLI_OF_SECOND -> nanos / 1000_000;

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

};

}

return range(field).checkValidIntValue(field.getFrom(this), field);

}

/**

@Override

public long getLong(TemporalField field) {

if (field instanceof ChronoField chronoField) {

return switch (chronoField) {

case NANO_OF_SECOND -> nanos;

case MICRO_OF_SECOND -> nanos / 1000;

case MILLI_OF_SECOND -> nanos / 1000_000;

case INSTANT_SECONDS -> seconds;

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

};

}

return field.getFrom(this);

}

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

/**

public long getEpochSecond() {

return seconds;

}

/**

public int getNano() {

return nanos;

}

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

/**

@Override

public Instant with(TemporalAdjuster adjuster) {

return (Instant) adjuster.adjustInto(this);

}

/**

@Override

public Instant with(TemporalField field, long newValue) {

if (field instanceof ChronoField chronoField) {

chronoField.checkValidValue(newValue);

return switch (chronoField) {

case MILLI_OF_SECOND -> {

int nval = (int) newValue * 1000_000;

yield nval != nanos ? create(seconds, nval) : this;

}

case MICRO_OF_SECOND -> {

int nval = (int) newValue * 1000;

yield nval != nanos ? create(seconds, nval) : this;

}

case NANO_OF_SECOND -> newValue != nanos ? create(seconds, (int) newValue) : this;

case INSTANT_SECONDS -> newValue != seconds ? create(newValue, nanos) : this;

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

};

}

return field.adjustInto(this, newValue);

}

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

/**

public Instant truncatedTo(TemporalUnit unit) {

if (unit == ChronoUnit.NANOS) {

return this;

}

Duration unitDur = unit.getDuration();

if (unitDur.getSeconds() > LocalTime.SECONDS_PER_DAY) {

throw new UnsupportedTemporalTypeException("Unit is too large to be used for truncation");

}

long dur = unitDur.toNanos();

if ((LocalTime.NANOS_PER_DAY % dur) != 0) {

throw new UnsupportedTemporalTypeException("Unit must divide into a standard day without remainder");

}

long nod = (seconds % LocalTime.SECONDS_PER_DAY) * LocalTime.NANOS_PER_SECOND + nanos;

long result = Math.floorDiv(nod, dur) * dur;

return plusNanos(result - nod);

}

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

/**

@Override

public Instant plus(TemporalAmount amountToAdd) {

return (Instant) amountToAdd.addTo(this);

}

/**

public Instant plusSaturating(Duration duration) {

if (duration.isNegative()) {

return until(Instant.MIN).compareTo(duration) >= 0 ? Instant.MIN : plus(duration);

} else {

return until(Instant.MAX).compareTo(duration) <= 0 ? Instant.MAX : plus(duration);

}

}

/**

@Override

public Instant plus(long amountToAdd, TemporalUnit unit) {

if (unit instanceof ChronoUnit chronoUnit) {

return switch (chronoUnit) {

case NANOS -> plusNanos(amountToAdd);

case MICROS -> plus(amountToAdd / 1000_000, (amountToAdd % 1000_000) * 1000);

case MILLIS -> plusMillis(amountToAdd);

case SECONDS -> plusSeconds(amountToAdd);

case MINUTES -> plusSeconds(Math.multiplyExact(amountToAdd, SECONDS_PER_MINUTE));

case HOURS -> plusSeconds(Math.multiplyExact(amountToAdd, SECONDS_PER_HOUR));

case HALF_DAYS -> plusSeconds(Math.multiplyExact(amountToAdd, SECONDS_PER_DAY / 2));

case DAYS -> plusSeconds(Math.multiplyExact(amountToAdd, SECONDS_PER_DAY));

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

};

}

return unit.addTo(this, amountToAdd);

}

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

/**

public Instant plusSeconds(long secondsToAdd) {

if (secondsToAdd == 0) {

return this;

}

long epochSec = Math.addExact(seconds, secondsToAdd);

return create(epochSec, nanos);

}

/**

public Instant plusMillis(long millisToAdd) {

return plus(millisToAdd / 1000, (millisToAdd % 1000) * 1000_000);

}

/**

public Instant plusNanos(long nanosToAdd) {

return plus(0, nanosToAdd);

}

/**

private Instant plus(long secondsToAdd, long nanosToAdd) {

if ((secondsToAdd | nanosToAdd) == 0) {

return this;

}

long epochSec = Math.addExact(seconds, secondsToAdd);

epochSec = Math.addExact(epochSec, nanosToAdd / NANOS_PER_SECOND);

nanosToAdd = nanosToAdd % NANOS_PER_SECOND;

long nanoAdjustment = nanos + nanosToAdd; // safe int+NANOS_PER_SECOND

return ofEpochSecond(epochSec, nanoAdjustment);

}

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

/**

@Override

public Instant minus(TemporalAmount amountToSubtract) {

return (Instant) amountToSubtract.subtractFrom(this);

}

/**