implements TemporalAmount, Comparable<Duration>, Serializable {

/**

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

/**

public static final Duration MIN = new Duration(Long.MIN_VALUE, 0);

/**

public static final Duration MAX = new Duration(Long.MAX_VALUE, 999_999_999);

/**

@java.io.Serial

private static final long serialVersionUID = 3078945930695997490L;

/**

private static final BigInteger BI_NANOS_PER_SECOND = BigInteger.valueOf(NANOS_PER_SECOND);

/**

private static class Lazy {

static final Pattern PATTERN =

Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)D)?" +

"(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?",

Pattern.CASE_INSENSITIVE);

}

/**

private final long seconds;

/**

private final int nanos;

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

/**

public static Duration ofDays(long days) {

return create(Math.multiplyExact(days, SECONDS_PER_DAY), 0);

}

/**

public static Duration ofHours(long hours) {

return create(Math.multiplyExact(hours, SECONDS_PER_HOUR), 0);

}

/**

public static Duration ofMinutes(long minutes) {

return create(Math.multiplyExact(minutes, SECONDS_PER_MINUTE), 0);

}

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

/**

public static Duration ofSeconds(long seconds) {

return create(seconds, 0);

}

/**

public static Duration ofSeconds(long seconds, long nanoAdjustment) {

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

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

return create(secs, nos);

}

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

/**

public static Duration ofMillis(long millis) {

long secs = millis / 1000;

int mos = (int) (millis % 1000);

if (mos < 0) {

mos += 1000;

secs--;

}

return create(secs, mos * 1000_000);

}

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

/**

public static Duration ofNanos(long nanos) {

long secs = nanos / NANOS_PER_SECOND;

int nos = (int) (nanos % NANOS_PER_SECOND);

if (nos < 0) {

nos += (int) NANOS_PER_SECOND;

secs--;

}

return create(secs, nos);

}

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

/**

public static Duration of(long amount, TemporalUnit unit) {

return ZERO.plus(amount, unit);

}

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

/**

public static Duration from(TemporalAmount amount) {

Objects.requireNonNull(amount, "amount");

Duration duration = ZERO;

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

duration = duration.plus(amount.get(unit), unit);

}

return duration;

}

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

/**

public static Duration parse(CharSequence text) {

Objects.requireNonNull(text, "text");

Matcher matcher = Lazy.PATTERN.matcher(text);

if (matcher.matches()) {

// check for letter T but no time sections

if (!charMatch(text, matcher.start(3), matcher.end(3), 'T')) {

boolean negate = charMatch(text, matcher.start(1), matcher.end(1), '-');

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

int hourStart = matcher.start(4), hourEnd = matcher.end(4);

int minuteStart = matcher.start(5), minuteEnd = matcher.end(5);

int secondStart = matcher.start(6), secondEnd = matcher.end(6);

int fractionStart = matcher.start(7), fractionEnd = matcher.end(7);

if (dayStart >= 0 || hourStart >= 0 || minuteStart >= 0 || secondStart >= 0) {

long daysAsSecs = parseNumber(text, dayStart, dayEnd, SECONDS_PER_DAY, "days");

long hoursAsSecs = parseNumber(text, hourStart, hourEnd, SECONDS_PER_HOUR, "hours");

long minsAsSecs = parseNumber(text, minuteStart, minuteEnd, SECONDS_PER_MINUTE, "minutes");

long seconds = parseNumber(text, secondStart, secondEnd, 1, "seconds");

boolean negativeSecs = secondStart >= 0 && text.charAt(secondStart) == '-';

int nanos = parseFraction(text, fractionStart, fractionEnd, negativeSecs ? -1 : 1);

try {

return create(negate, daysAsSecs, hoursAsSecs, minsAsSecs, seconds, nanos);

} catch (ArithmeticException ex) {

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

}

}

}

}

throw new DateTimeParseException("Text cannot be parsed to a Duration", 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 long parseNumber(CharSequence text, int start, int end, int multiplier, String errorText) {

// regex limits to [-+]?[0-9]+

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

return 0;

}

try {

long val = Long.parseLong(text, start, end, 10);

return Math.multiplyExact(val, multiplier);

} catch (NumberFormatException | ArithmeticException ex) {

throw new DateTimeParseException("Text cannot be parsed to a Duration: " + errorText, text, 0, ex);

}

}

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

// regex limits to [0-9]{0,9}

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

return 0;

}

try {

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

// for number strings smaller than 9 digits, interpret as if there

// were trailing zeros

for (int i = end - start; i < 9; i++) {

fraction *= 10;

}

return fraction * negate;

} catch (NumberFormatException | ArithmeticException ex) {

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

}

}

private static Duration create(boolean negate, long daysAsSecs, long hoursAsSecs, long minsAsSecs, long secs, int nanos) {

long seconds = Math.addExact(daysAsSecs, Math.addExact(hoursAsSecs, Math.addExact(minsAsSecs, secs)));

if (negate) {

return ofSeconds(seconds, nanos).negated();

}

return ofSeconds(seconds, nanos);

}

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

/**

public static Duration between(Temporal startInclusive, Temporal endExclusive) {

long secs = startInclusive.until(endExclusive, SECONDS);

if (secs == 0) {

// We don't know which Temporal is earlier, so the adjustment below would not work.

// But we do know that there's no danger of until(NANOS) overflowing in that case.

return ofNanos(startInclusive.until(endExclusive, NANOS));

}

long nanos;

try {

nanos = endExclusive.getLong(NANO_OF_SECOND) - startInclusive.getLong(NANO_OF_SECOND);

} catch (DateTimeException ex2) {

nanos = 0;

}

if (nanos < 0 && secs > 0) {

// ofSeconds will subtract one even though until(SECONDS) already gave the correct

// number of seconds. So compensate. Similarly for the secs < 0 case below.

secs++;

} else if (nanos > 0 && secs < 0) {

secs--;

}

return ofSeconds(secs, nanos);

}

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

/**

private static Duration create(long seconds, int nanoAdjustment) {

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

return ZERO;

}

return new Duration(seconds, nanoAdjustment);

}

/**

private Duration(long seconds, int nanos) {

this.seconds = seconds;

this.nanos = nanos;

}

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

/**

@Override

public long get(TemporalUnit unit) {

if (unit == SECONDS) {

return seconds;

} else if (unit == NANOS) {

return nanos;

} else {

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

}

}

/**

@Override

public List<TemporalUnit> getUnits() {

return DurationUnits.UNITS;

}

/**

private static class DurationUnits {

static final List<TemporalUnit> UNITS = List.of(SECONDS, NANOS);

}

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

/**

public boolean isPositive() {

return (seconds | nanos) > 0;

}

/**

public boolean isZero() {

return (seconds | nanos) == 0;

}

/**

public boolean isNegative() {

return seconds < 0;

}

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

/**

public long getSeconds() {

return seconds;

}

/**

public int getNano() {

return nanos;

}

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

/**

public Duration withSeconds(long seconds) {

return create(seconds, nanos);

}

/**

public Duration withNanos(int nanoOfSecond) {

NANO_OF_SECOND.checkValidIntValue(nanoOfSecond);

return create(seconds, nanoOfSecond);

}

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

/**

public Duration plus(Duration duration) {

return plus(duration.getSeconds(), duration.getNano());

}

/**

public Duration plus(long amountToAdd, TemporalUnit unit) {

Objects.requireNonNull(unit, "unit");

if (unit == DAYS) {

return plus(Math.multiplyExact(amountToAdd, SECONDS_PER_DAY), 0);

}

if (unit.isDurationEstimated()) {

throw new UnsupportedTemporalTypeException("Unit must not have an estimated duration");

}

if (amountToAdd == 0) {

return this;

}

if (unit instanceof ChronoUnit chronoUnit) {

return switch (chronoUnit) {

case NANOS -> plusNanos(amountToAdd);

case MICROS -> plusSeconds((amountToAdd / (1000_000L * 1000)) * 1000).plusNanos((amountToAdd % (1000_000L * 1000)) * 1000);

case MILLIS -> plusMillis(amountToAdd);

case SECONDS -> plusSeconds(amountToAdd);

default -> plusSeconds(Math.multiplyExact(unit.getDuration().seconds, amountToAdd));

};

}

Duration duration = unit.getDuration().multipliedBy(amountToAdd);

return plusSeconds(duration.getSeconds()).plusNanos(duration.getNano());

}

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

/**

public Duration plusDays(long daysToAdd) {

return plus(Math.multiplyExact(daysToAdd, SECONDS_PER_DAY), 0);

}

/**

public Duration plusHours(long hoursToAdd) {

return plus(Math.multiplyExact(hoursToAdd, SECONDS_PER_HOUR), 0);

}

/**

public Duration plusMinutes(long minutesToAdd) {

return plus(Math.multiplyExact(minutesToAdd, SECONDS_PER_MINUTE), 0);

}

/**

public Duration plusSeconds(long secondsToAdd) {

return plus(secondsToAdd, 0);

}

/**

public Duration plusMillis(long millisToAdd) {

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

}

/**

public Duration plusNanos(long nanosToAdd) {

return plus(0, nanosToAdd);

}

/**

private Duration 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 ofSeconds(epochSec, nanoAdjustment);

}

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

/**

public Duration minus(Duration duration) {

long secsToSubtract = duration.getSeconds();

int nanosToSubtract = duration.getNano();

if (secsToSubtract == Long.MIN_VALUE) {

return plus(Long.MAX_VALUE, -nanosToSubtract).plus(1, 0);

}

return plus(-secsToSubtract, -nanosToSubtract);

}

/**

public Duration minus(long amountToSubtract, TemporalUnit unit) {

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

}

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

/**

public Duration minusDays(long daysToSubtract) {

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

}

/**

public Duration minusHours(long hoursToSubtract) {

return (hoursToSubtract == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1) : plusHours(-hoursToSubtract));

}

/**

public Duration minusMinutes(long minutesToSubtract) {

return (minutesToSubtract == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1) : plusMinutes(-minutesToSubtract));

}

/**

public Duration minusSeconds(long secondsToSubtract) {

return (secondsToSubtract == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1) : plusSeconds(-secondsToSubtract));

}

/**

public Duration minusMillis(long millisToSubtract) {

return (millisToSubtract == Long.MIN_VALUE ? plusMillis(Long.MAX_VALUE).plusMillis(1) : plusMillis(-millisToSubtract));

}

/**