539 lines
19 KiB
Java
539 lines
19 KiB
Java
package o;
|
|
|
|
import java.io.DataInput;
|
|
import java.io.DataOutput;
|
|
import java.io.IOException;
|
|
import java.io.InvalidObjectException;
|
|
import java.io.ObjectStreamException;
|
|
import java.io.Serializable;
|
|
import java.math.BigDecimal;
|
|
import java.math.BigInteger;
|
|
import java.math.RoundingMode;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
import org.threeten.bp.DateTimeException;
|
|
import org.threeten.bp.format.DateTimeParseException;
|
|
import org.threeten.bp.temporal.UnsupportedTemporalTypeException;
|
|
|
|
/* renamed from: o.gso, reason: case insensitive filesystem */
|
|
/* loaded from: classes.dex */
|
|
public final class C15519gso implements gtN, Comparable<C15519gso>, Serializable {
|
|
private static final int NANOS_PER_MILLI = 1000000;
|
|
private static final int NANOS_PER_SECOND = 1000000000;
|
|
private static final long serialVersionUID = 3078945930695997490L;
|
|
private final int nanos;
|
|
private final long seconds;
|
|
public static final C15519gso ZERO = new C15519gso(0, 0);
|
|
private static final BigInteger BI_NANOS_PER_SECOND = BigInteger.valueOf(1000000000);
|
|
private static final Pattern PATTERN = Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)D)?(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?", 2);
|
|
|
|
public static C15519gso ofDays(long j) {
|
|
return create(gtG.safeMultiply(j, 86400), 0);
|
|
}
|
|
|
|
public static C15519gso ofHours(long j) {
|
|
return create(gtG.safeMultiply(j, 3600), 0);
|
|
}
|
|
|
|
public static C15519gso ofMinutes(long j) {
|
|
return create(gtG.safeMultiply(j, 60), 0);
|
|
}
|
|
|
|
public static C15519gso ofSeconds(long j) {
|
|
return create(j, 0);
|
|
}
|
|
|
|
public static C15519gso ofSeconds(long j, long j2) {
|
|
return create(gtG.safeAdd(j, gtG.floorDiv(j2, 1000000000L)), gtG.floorMod(j2, 1000000000));
|
|
}
|
|
|
|
public static C15519gso ofMillis(long j) {
|
|
long j2 = j / 1000;
|
|
int i = (int) (j % 1000);
|
|
if (i < 0) {
|
|
i += 1000;
|
|
j2--;
|
|
}
|
|
return create(j2, i * NANOS_PER_MILLI);
|
|
}
|
|
|
|
public static C15519gso ofNanos(long j) {
|
|
long j2 = j / 1000000000;
|
|
int i = (int) (j % 1000000000);
|
|
if (i < 0) {
|
|
i += 1000000000;
|
|
j2--;
|
|
}
|
|
return create(j2, i);
|
|
}
|
|
|
|
public static C15519gso of(long j, InterfaceC15539gtV interfaceC15539gtV) {
|
|
return ZERO.plus(j, interfaceC15539gtV);
|
|
}
|
|
|
|
public static C15519gso from(gtN gtn) {
|
|
gtG.requireNonNull(gtn, "amount");
|
|
C15519gso c15519gso = ZERO;
|
|
for (InterfaceC15539gtV interfaceC15539gtV : gtn.getUnits()) {
|
|
c15519gso = c15519gso.plus(gtn.get(interfaceC15539gtV), interfaceC15539gtV);
|
|
}
|
|
return c15519gso;
|
|
}
|
|
|
|
public static C15519gso between(InterfaceC15536gtL interfaceC15536gtL, InterfaceC15536gtL interfaceC15536gtL2) {
|
|
long until = interfaceC15536gtL.until(interfaceC15536gtL2, gtH.SECONDS);
|
|
long j = 0;
|
|
if (interfaceC15536gtL.isSupported(EnumC15534gtD.NANO_OF_SECOND) && interfaceC15536gtL2.isSupported(EnumC15534gtD.NANO_OF_SECOND)) {
|
|
try {
|
|
long j2 = interfaceC15536gtL.getLong(EnumC15534gtD.NANO_OF_SECOND);
|
|
long j3 = interfaceC15536gtL2.getLong(EnumC15534gtD.NANO_OF_SECOND) - j2;
|
|
if (until > 0 && j3 < 0) {
|
|
j = j3 + 1000000000;
|
|
} else if (until >= 0 || j3 <= 0) {
|
|
if (until == 0 && j3 != 0) {
|
|
try {
|
|
until = interfaceC15536gtL.until(interfaceC15536gtL2.with(EnumC15534gtD.NANO_OF_SECOND, j2), gtH.SECONDS);
|
|
} catch (ArithmeticException | DateTimeException unused) {
|
|
}
|
|
}
|
|
j = j3;
|
|
} else {
|
|
j = j3 - 1000000000;
|
|
}
|
|
} catch (ArithmeticException | DateTimeException unused2) {
|
|
}
|
|
}
|
|
return ofSeconds(until, j);
|
|
}
|
|
|
|
public static C15519gso parse(CharSequence charSequence) {
|
|
gtG.requireNonNull(charSequence, "text");
|
|
Matcher matcher = PATTERN.matcher(charSequence);
|
|
if (matcher.matches() && !"T".equals(matcher.group(3))) {
|
|
int i = 1;
|
|
boolean equals = "-".equals(matcher.group(1));
|
|
String group = matcher.group(2);
|
|
String group2 = matcher.group(4);
|
|
String group3 = matcher.group(5);
|
|
String group4 = matcher.group(6);
|
|
String group5 = matcher.group(7);
|
|
if (group != null || group2 != null || group3 != null || group4 != null) {
|
|
long parseNumber = parseNumber(charSequence, group, 86400, "days");
|
|
long parseNumber2 = parseNumber(charSequence, group2, 3600, "hours");
|
|
long parseNumber3 = parseNumber(charSequence, group3, 60, "minutes");
|
|
long parseNumber4 = parseNumber(charSequence, group4, 1, "seconds");
|
|
if (group4 != null && group4.charAt(0) == '-') {
|
|
i = -1;
|
|
}
|
|
try {
|
|
return create(equals, parseNumber, parseNumber2, parseNumber3, parseNumber4, parseFraction(charSequence, group5, i));
|
|
} catch (ArithmeticException e) {
|
|
throw ((DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: overflow", charSequence, 0).initCause(e));
|
|
}
|
|
}
|
|
}
|
|
throw new DateTimeParseException("Text cannot be parsed to a Duration", charSequence, 0);
|
|
}
|
|
|
|
private static long parseNumber(CharSequence charSequence, String str, int i, String str2) {
|
|
if (str == null) {
|
|
return 0L;
|
|
}
|
|
try {
|
|
if (str.startsWith("+")) {
|
|
str = str.substring(1);
|
|
}
|
|
return gtG.safeMultiply(Long.parseLong(str), i);
|
|
} catch (ArithmeticException e) {
|
|
throw ((DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: ".concat(String.valueOf(str2)), charSequence, 0).initCause(e));
|
|
} catch (NumberFormatException e2) {
|
|
throw ((DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: ".concat(String.valueOf(str2)), charSequence, 0).initCause(e2));
|
|
}
|
|
}
|
|
|
|
private static int parseFraction(CharSequence charSequence, String str, int i) {
|
|
if (str == null || str.length() == 0) {
|
|
return 0;
|
|
}
|
|
try {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(str);
|
|
sb.append("000000000");
|
|
return Integer.parseInt(sb.toString().substring(0, 9)) * i;
|
|
} catch (ArithmeticException e) {
|
|
throw ((DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: fraction", charSequence, 0).initCause(e));
|
|
} catch (NumberFormatException e2) {
|
|
throw ((DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: fraction", charSequence, 0).initCause(e2));
|
|
}
|
|
}
|
|
|
|
private static C15519gso create(boolean z, long j, long j2, long j3, long j4, int i) {
|
|
long safeAdd = gtG.safeAdd(j, gtG.safeAdd(j2, gtG.safeAdd(j3, j4)));
|
|
if (z) {
|
|
return ofSeconds(safeAdd, i).negated();
|
|
}
|
|
return ofSeconds(safeAdd, i);
|
|
}
|
|
|
|
private static C15519gso create(long j, int i) {
|
|
return (((long) i) | j) == 0 ? ZERO : new C15519gso(j, i);
|
|
}
|
|
|
|
private C15519gso(long j, int i) {
|
|
this.seconds = j;
|
|
this.nanos = i;
|
|
}
|
|
|
|
@Override // o.gtN
|
|
public final List<InterfaceC15539gtV> getUnits() {
|
|
return Collections.unmodifiableList(Arrays.asList(gtH.SECONDS, gtH.NANOS));
|
|
}
|
|
|
|
@Override // o.gtN
|
|
public final long get(InterfaceC15539gtV interfaceC15539gtV) {
|
|
if (interfaceC15539gtV == gtH.SECONDS) {
|
|
return this.seconds;
|
|
}
|
|
if (interfaceC15539gtV == gtH.NANOS) {
|
|
return this.nanos;
|
|
}
|
|
throw new UnsupportedTemporalTypeException("Unsupported unit: ".concat(String.valueOf(interfaceC15539gtV)));
|
|
}
|
|
|
|
public final C15519gso withSeconds(long j) {
|
|
return create(j, this.nanos);
|
|
}
|
|
|
|
public final C15519gso withNanos(int i) {
|
|
EnumC15534gtD.NANO_OF_SECOND.checkValidIntValue(i);
|
|
return create(this.seconds, i);
|
|
}
|
|
|
|
public final C15519gso plus(C15519gso c15519gso) {
|
|
return plus(c15519gso.getSeconds(), c15519gso.getNano());
|
|
}
|
|
|
|
public final C15519gso plus(long j, InterfaceC15539gtV interfaceC15539gtV) {
|
|
gtG.requireNonNull(interfaceC15539gtV, "unit");
|
|
if (interfaceC15539gtV == gtH.DAYS) {
|
|
return plus(gtG.safeMultiply(j, 86400), 0L);
|
|
}
|
|
if (interfaceC15539gtV.isDurationEstimated()) {
|
|
throw new DateTimeException("Unit must not have an estimated duration");
|
|
}
|
|
if (j == 0) {
|
|
return this;
|
|
}
|
|
if (interfaceC15539gtV instanceof gtH) {
|
|
int i = AnonymousClass3.$SwitchMap$org$threeten$bp$temporal$ChronoUnit[((gtH) interfaceC15539gtV).ordinal()];
|
|
if (i == 1) {
|
|
return plusNanos(j);
|
|
}
|
|
if (i == 2) {
|
|
return plusSeconds((j / 1000000000) * 1000).plusNanos((j % 1000000000) * 1000);
|
|
}
|
|
if (i == 3) {
|
|
return plusMillis(j);
|
|
}
|
|
if (i == 4) {
|
|
return plusSeconds(j);
|
|
}
|
|
return plusSeconds(gtG.safeMultiply(interfaceC15539gtV.getDuration().seconds, j));
|
|
}
|
|
return plusSeconds(interfaceC15539gtV.getDuration().multipliedBy(j).getSeconds()).plusNanos(r7.getNano());
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: o.gso$3, reason: invalid class name */
|
|
/* loaded from: classes.dex */
|
|
public static /* synthetic */ class AnonymousClass3 {
|
|
static final int[] $SwitchMap$org$threeten$bp$temporal$ChronoUnit;
|
|
|
|
static {
|
|
int[] iArr = new int[gtH.values().length];
|
|
$SwitchMap$org$threeten$bp$temporal$ChronoUnit = iArr;
|
|
try {
|
|
iArr[gtH.NANOS.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$org$threeten$bp$temporal$ChronoUnit[gtH.MICROS.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$org$threeten$bp$temporal$ChronoUnit[gtH.MILLIS.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
$SwitchMap$org$threeten$bp$temporal$ChronoUnit[gtH.SECONDS.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public final C15519gso plusDays(long j) {
|
|
return plus(gtG.safeMultiply(j, 86400), 0L);
|
|
}
|
|
|
|
public final C15519gso plusHours(long j) {
|
|
return plus(gtG.safeMultiply(j, 3600), 0L);
|
|
}
|
|
|
|
public final C15519gso plusMinutes(long j) {
|
|
return plus(gtG.safeMultiply(j, 60), 0L);
|
|
}
|
|
|
|
public final C15519gso plusSeconds(long j) {
|
|
return plus(j, 0L);
|
|
}
|
|
|
|
public final C15519gso plusMillis(long j) {
|
|
return plus(j / 1000, (j % 1000) * 1000000);
|
|
}
|
|
|
|
public final C15519gso plusNanos(long j) {
|
|
return plus(0L, j);
|
|
}
|
|
|
|
private C15519gso plus(long j, long j2) {
|
|
return (j | j2) == 0 ? this : ofSeconds(gtG.safeAdd(gtG.safeAdd(this.seconds, j), j2 / 1000000000), this.nanos + (j2 % 1000000000));
|
|
}
|
|
|
|
public final C15519gso minus(C15519gso c15519gso) {
|
|
long seconds = c15519gso.getSeconds();
|
|
int nano = c15519gso.getNano();
|
|
if (seconds == Long.MIN_VALUE) {
|
|
return plus(Long.MAX_VALUE, -nano).plus(1L, 0L);
|
|
}
|
|
return plus(-seconds, -nano);
|
|
}
|
|
|
|
public final C15519gso minus(long j, InterfaceC15539gtV interfaceC15539gtV) {
|
|
return j == Long.MIN_VALUE ? plus(Long.MAX_VALUE, interfaceC15539gtV).plus(1L, interfaceC15539gtV) : plus(-j, interfaceC15539gtV);
|
|
}
|
|
|
|
public final C15519gso minusDays(long j) {
|
|
return j == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1L) : plusDays(-j);
|
|
}
|
|
|
|
public final C15519gso minusHours(long j) {
|
|
return j == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1L) : plusHours(-j);
|
|
}
|
|
|
|
public final C15519gso minusMinutes(long j) {
|
|
return j == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1L) : plusMinutes(-j);
|
|
}
|
|
|
|
public final C15519gso minusSeconds(long j) {
|
|
return j == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1L) : plusSeconds(-j);
|
|
}
|
|
|
|
public final C15519gso minusMillis(long j) {
|
|
return j == Long.MIN_VALUE ? plusMillis(Long.MAX_VALUE).plusMillis(1L) : plusMillis(-j);
|
|
}
|
|
|
|
public final C15519gso minusNanos(long j) {
|
|
return j == Long.MIN_VALUE ? plusNanos(Long.MAX_VALUE).plusNanos(1L) : plusNanos(-j);
|
|
}
|
|
|
|
public final C15519gso multipliedBy(long j) {
|
|
return j == 0 ? ZERO : j == 1 ? this : create(toSeconds().multiply(BigDecimal.valueOf(j)));
|
|
}
|
|
|
|
public final C15519gso dividedBy(long j) {
|
|
if (j != 0) {
|
|
return j == 1 ? this : create(toSeconds().divide(BigDecimal.valueOf(j), RoundingMode.DOWN));
|
|
}
|
|
throw new ArithmeticException("Cannot divide by zero");
|
|
}
|
|
|
|
private BigDecimal toSeconds() {
|
|
return BigDecimal.valueOf(this.seconds).add(BigDecimal.valueOf(this.nanos, 9));
|
|
}
|
|
|
|
private static C15519gso create(BigDecimal bigDecimal) {
|
|
BigInteger bigIntegerExact = bigDecimal.movePointRight(9).toBigIntegerExact();
|
|
BigInteger[] divideAndRemainder = bigIntegerExact.divideAndRemainder(BI_NANOS_PER_SECOND);
|
|
if (divideAndRemainder[0].bitLength() > 63) {
|
|
throw new ArithmeticException("Exceeds capacity of Duration: ".concat(String.valueOf(bigIntegerExact)));
|
|
}
|
|
return ofSeconds(divideAndRemainder[0].longValue(), divideAndRemainder[1].intValue());
|
|
}
|
|
|
|
public final C15519gso negated() {
|
|
return multipliedBy(-1L);
|
|
}
|
|
|
|
public final C15519gso abs() {
|
|
return isNegative() ? negated() : this;
|
|
}
|
|
|
|
@Override // o.gtN
|
|
public final InterfaceC15536gtL addTo(InterfaceC15536gtL interfaceC15536gtL) {
|
|
long j = this.seconds;
|
|
if (j != 0) {
|
|
interfaceC15536gtL = interfaceC15536gtL.plus(j, gtH.SECONDS);
|
|
}
|
|
int i = this.nanos;
|
|
return i != 0 ? interfaceC15536gtL.plus(i, gtH.NANOS) : interfaceC15536gtL;
|
|
}
|
|
|
|
@Override // o.gtN
|
|
public final InterfaceC15536gtL subtractFrom(InterfaceC15536gtL interfaceC15536gtL) {
|
|
long j = this.seconds;
|
|
if (j != 0) {
|
|
interfaceC15536gtL = interfaceC15536gtL.minus(j, gtH.SECONDS);
|
|
}
|
|
int i = this.nanos;
|
|
return i != 0 ? interfaceC15536gtL.minus(i, gtH.NANOS) : interfaceC15536gtL;
|
|
}
|
|
|
|
public final long toDays() {
|
|
return this.seconds / 86400;
|
|
}
|
|
|
|
public final long toHours() {
|
|
return this.seconds / 3600;
|
|
}
|
|
|
|
public final long toMinutes() {
|
|
return this.seconds / 60;
|
|
}
|
|
|
|
public final long toMillis() {
|
|
return gtG.safeAdd(gtG.safeMultiply(this.seconds, 1000), this.nanos / NANOS_PER_MILLI);
|
|
}
|
|
|
|
public final long toNanos() {
|
|
return gtG.safeAdd(gtG.safeMultiply(this.seconds, 1000000000), this.nanos);
|
|
}
|
|
|
|
public final long toDaysPart() {
|
|
return this.seconds / 86400;
|
|
}
|
|
|
|
public final int toHoursPart() {
|
|
return (int) (toHours() % 24);
|
|
}
|
|
|
|
public final int toMinutesPart() {
|
|
return (int) (toMinutes() % 60);
|
|
}
|
|
|
|
public final int toSecondsPart() {
|
|
return (int) (this.seconds % 60);
|
|
}
|
|
|
|
public final int toMillisPart() {
|
|
return this.nanos / NANOS_PER_MILLI;
|
|
}
|
|
|
|
@Override // java.lang.Comparable
|
|
public final int compareTo(C15519gso c15519gso) {
|
|
int compareLongs = gtG.compareLongs(this.seconds, c15519gso.seconds);
|
|
return compareLongs != 0 ? compareLongs : this.nanos - c15519gso.nanos;
|
|
}
|
|
|
|
public final boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof C15519gso)) {
|
|
return false;
|
|
}
|
|
C15519gso c15519gso = (C15519gso) obj;
|
|
return this.seconds == c15519gso.seconds && this.nanos == c15519gso.nanos;
|
|
}
|
|
|
|
public final String toString() {
|
|
if (this == ZERO) {
|
|
return "PT0S";
|
|
}
|
|
long j = this.seconds;
|
|
long j2 = j / 3600;
|
|
int i = (int) ((j % 3600) / 60);
|
|
int i2 = (int) (j % 60);
|
|
StringBuilder sb = new StringBuilder(24);
|
|
sb.append("PT");
|
|
if (j2 != 0) {
|
|
sb.append(j2);
|
|
sb.append('H');
|
|
}
|
|
if (i != 0) {
|
|
sb.append(i);
|
|
sb.append('M');
|
|
}
|
|
if (i2 == 0 && this.nanos == 0 && sb.length() > 2) {
|
|
return sb.toString();
|
|
}
|
|
if (i2 >= 0 || this.nanos <= 0) {
|
|
sb.append(i2);
|
|
} else if (i2 == -1) {
|
|
sb.append("-0");
|
|
} else {
|
|
sb.append(i2 + 1);
|
|
}
|
|
if (this.nanos > 0) {
|
|
int length = sb.length();
|
|
if (i2 < 0) {
|
|
sb.append(2000000000 - this.nanos);
|
|
} else {
|
|
sb.append(this.nanos + 1000000000);
|
|
}
|
|
while (sb.charAt(sb.length() - 1) == '0') {
|
|
sb.setLength(sb.length() - 1);
|
|
}
|
|
sb.setCharAt(length, '.');
|
|
}
|
|
sb.append('S');
|
|
return sb.toString();
|
|
}
|
|
|
|
private Object writeReplace() {
|
|
return new C15501gsD((byte) 1, this);
|
|
}
|
|
|
|
private Object readResolve() throws ObjectStreamException {
|
|
throw new InvalidObjectException("Deserialization via serialization delegate");
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
public final void writeExternal(DataOutput dataOutput) throws IOException {
|
|
dataOutput.writeLong(this.seconds);
|
|
dataOutput.writeInt(this.nanos);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
public static C15519gso readExternal(DataInput dataInput) throws IOException {
|
|
return ofSeconds(dataInput.readLong(), dataInput.readInt());
|
|
}
|
|
|
|
public final int toNanosPart() {
|
|
return this.nanos;
|
|
}
|
|
|
|
public final boolean isZero() {
|
|
return (this.seconds | ((long) this.nanos)) == 0;
|
|
}
|
|
|
|
public final boolean isNegative() {
|
|
return this.seconds < 0;
|
|
}
|
|
|
|
public final int hashCode() {
|
|
long j = this.seconds;
|
|
return ((int) (j ^ (j >>> 32))) + (this.nanos * 51);
|
|
}
|
|
|
|
public final long getSeconds() {
|
|
return this.seconds;
|
|
}
|
|
|
|
public final int getNano() {
|
|
return this.nanos;
|
|
}
|
|
}
|