Initial commit

sources/com/thoughtworks/xstream/converters/time/AbstractChronoLocalDateConverter.java

@@ -0,0 +1,63 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.DateTimeException;
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.Chronology;
+import java.time.chrono.Era;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes.dex */
+abstract class AbstractChronoLocalDateConverter<E extends Era> extends AbstractSingleValueConverter {
+    private static final Pattern CHRONO_DATE_PATTERN = Pattern.compile("^ (\\w+) (\\d+)-(\\d+)-(\\d+)$");
+
+    AbstractChronoLocalDateConverter() {
+    }
+
+    protected abstract ChronoLocalDate chronoLocalDateOf(E e, int i, int i2, int i3);
+
+    protected abstract E eraOf(String str);
+
+    protected ChronoLocalDate parseChronoLocalDate(String str, String str2, Set<Chronology> set) {
+        ConversionException conversionException = null;
+        if (str != null) {
+            Iterator<Chronology> it = set.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                String id = it.next().getId();
+                if (str.startsWith(id + ' ')) {
+                    Matcher matcher = CHRONO_DATE_PATTERN.matcher(str.subSequence(id.length(), str.length()));
+                    if (matcher.matches()) {
+                        try {
+                            E eraOf = eraOf(matcher.group(1));
+                            if (eraOf != null) {
+                                try {
+                                    return chronoLocalDateOf(eraOf, Integer.parseInt(matcher.group(2)), Integer.parseInt(matcher.group(3)), Integer.parseInt(matcher.group(4)));
+                                } catch (DateTimeException e) {
+                                    conversionException = new ConversionException("Cannot parse value as " + str2 + " date", e);
+                                    if (conversionException == null) {
+                                        conversionException = new ConversionException("Cannot parse value as " + str2 + " date");
+                                    }
+                                    conversionException.add("value", str);
+                                    throw conversionException;
+                                }
+                            }
+                        } catch (IllegalArgumentException e2) {
+                            conversionException = new ConversionException("Cannot parse value as " + str2 + " date", e2);
+                        }
+                    } else {
+                        continue;
+                    }
+                }
+            }
+        } else {
+            return null;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/ChronologyConverter.java

@@ -0,0 +1,36 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.DateTimeException;
+import java.time.chrono.Chronology;
+
+/* loaded from: classes.dex */
+public class ChronologyConverter implements SingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && Chronology.class.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return ((Chronology) obj).getId();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Chronology fromString(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            return Chronology.of(str);
+        } catch (DateTimeException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as chronology", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/DurationConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.Duration;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class DurationConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return Duration.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Duration fromString(String str) {
+        try {
+            return Duration.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as duration", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/HijrahDateConverter.java

@@ -0,0 +1,47 @@
+package com.thoughtworks.xstream.converters.time;
+
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.Chronology;
+import java.time.chrono.HijrahChronology;
+import java.time.chrono.HijrahDate;
+import java.time.chrono.HijrahEra;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class HijrahDateConverter extends AbstractChronoLocalDateConverter<HijrahEra> {
+    private final Set<Chronology> hijrahChronologies = new HashSet();
+
+    public HijrahDateConverter() {
+        for (Chronology chronology : Chronology.getAvailableChronologies()) {
+            if (chronology instanceof HijrahChronology) {
+                this.hijrahChronologies.add(chronology);
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return HijrahDate.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return parseChronoLocalDate(str, "Hijrah", this.hijrahChronologies);
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public ChronoLocalDate chronoLocalDateOf(HijrahEra hijrahEra, int i, int i2, int i3) {
+        if (hijrahEra != null) {
+            return HijrahDate.of(i, i2, i3);
+        }
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public HijrahEra eraOf(String str) {
+        return HijrahEra.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/InstantConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.Instant;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class InstantConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return Instant.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Instant fromString(String str) {
+        try {
+            return Instant.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as instant", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/JapaneseDateConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.time;
+
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.JapaneseChronology;
+import java.time.chrono.JapaneseDate;
+import java.time.chrono.JapaneseEra;
+import java.util.Collections;
+
+/* loaded from: classes.dex */
+public class JapaneseDateConverter extends AbstractChronoLocalDateConverter<JapaneseEra> {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return JapaneseDate.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return parseChronoLocalDate(str, "Japanese", Collections.singleton(JapaneseChronology.INSTANCE));
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public ChronoLocalDate chronoLocalDateOf(JapaneseEra japaneseEra, int i, int i2, int i3) {
+        return JapaneseDate.of(japaneseEra, i, i2, i3);
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public JapaneseEra eraOf(String str) {
+        return JapaneseEra.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/JapaneseEraConverter.java

@@ -0,0 +1,27 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.chrono.JapaneseEra;
+
+/* loaded from: classes.dex */
+public class JapaneseEraConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && JapaneseEra.class.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public JapaneseEra fromString(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            return JapaneseEra.valueOf(str);
+        } catch (IllegalArgumentException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as Japanese era", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/LocalDateConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class LocalDateConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return LocalDate.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return LocalDate.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as local date", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/LocalDateTimeConverter.java

@@ -0,0 +1,38 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoField;
+
+/* loaded from: classes.dex */
+public class LocalDateTimeConverter implements SingleValueConverter {
+    private static final DateTimeFormatter FORMATTER = new DateTimeFormatterBuilder().appendPattern("uuuu-MM-dd'T'HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter();
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return LocalDateTime.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return LocalDateTime.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as local date time", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return FORMATTER.format((LocalDateTime) obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/LocalTimeConverter.java

@@ -0,0 +1,38 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoField;
+
+/* loaded from: classes.dex */
+public class LocalTimeConverter implements SingleValueConverter {
+    private static final DateTimeFormatter FORMATTER = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter();
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return LocalTime.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return LocalTime.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as local time", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return FORMATTER.format((LocalTime) obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/MinguoDateConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.time;
+
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.MinguoChronology;
+import java.time.chrono.MinguoDate;
+import java.time.chrono.MinguoEra;
+import java.util.Collections;
+
+/* loaded from: classes.dex */
+public class MinguoDateConverter extends AbstractChronoLocalDateConverter<MinguoEra> {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return MinguoDate.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return parseChronoLocalDate(str, "Minguo", Collections.singleton(MinguoChronology.INSTANCE));
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public ChronoLocalDate chronoLocalDateOf(MinguoEra minguoEra, int i, int i2, int i3) {
+        return MinguoDate.of(i, i2, i3);
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public MinguoEra eraOf(String str) {
+        return MinguoEra.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/MonthDayConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.MonthDay;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class MonthDayConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return MonthDay.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public MonthDay fromString(String str) {
+        try {
+            return MonthDay.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as month day", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/OffsetDateTimeConverter.java

@@ -0,0 +1,38 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoField;
+
+/* loaded from: classes.dex */
+public class OffsetDateTimeConverter implements SingleValueConverter {
+    private static final DateTimeFormatter FORMATTER = new DateTimeFormatterBuilder().appendPattern("uuuu-MM-dd'T'HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).appendOffsetId().toFormatter();
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return OffsetDateTime.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return OffsetDateTime.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as offset date time", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return FORMATTER.format((OffsetDateTime) obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/OffsetTimeConverter.java

@@ -0,0 +1,38 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.OffsetTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoField;
+
+/* loaded from: classes.dex */
+public class OffsetTimeConverter implements SingleValueConverter {
+    private static final DateTimeFormatter FORMATTER = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).appendOffsetId().toFormatter();
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return OffsetTime.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return OffsetTime.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as offset time", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return FORMATTER.format((OffsetTime) obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/PeriodConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.Period;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class PeriodConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return Period.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Period fromString(String str) {
+        try {
+            return Period.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse period value", e);
+            conversionException.add("period", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/SystemClockConverter.java

@@ -0,0 +1,41 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.time.Clock;
+import java.time.ZoneId;
+
+/* loaded from: classes.dex */
+public class SystemClockConverter implements Converter {
+    private final Mapper mapper;
+    private final Class<?> type = Clock.systemUTC().getClass();
+
+    public SystemClockConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls == this.type;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedMember(Clock.class, "zone"), null);
+        marshallingContext.convertAnother(((Clock) obj).getZone());
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        hierarchicalStreamReader.moveDown();
+        ZoneId zoneId = (ZoneId) unmarshallingContext.convertAnother(null, ZoneId.class);
+        hierarchicalStreamReader.moveUp();
+        return Clock.system(zoneId);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/ThaiBuddhistDateConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.time;
+
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.ThaiBuddhistChronology;
+import java.time.chrono.ThaiBuddhistDate;
+import java.time.chrono.ThaiBuddhistEra;
+import java.util.Collections;
+
+/* loaded from: classes.dex */
+public class ThaiBuddhistDateConverter extends AbstractChronoLocalDateConverter<ThaiBuddhistEra> {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return ThaiBuddhistDate.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return parseChronoLocalDate(str, "Thai Buddhist", Collections.singleton(ThaiBuddhistChronology.INSTANCE));
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public ChronoLocalDate chronoLocalDateOf(ThaiBuddhistEra thaiBuddhistEra, int i, int i2, int i3) {
+        return ThaiBuddhistDate.of(i, i2, i3);
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // com.thoughtworks.xstream.converters.time.AbstractChronoLocalDateConverter
+    public ThaiBuddhistEra eraOf(String str) {
+        return ThaiBuddhistEra.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/ValueRangeConverter.java

@@ -0,0 +1,64 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.time.temporal.ValueRange;
+import java.util.HashMap;
+
+/* loaded from: classes.dex */
+public class ValueRangeConverter implements Converter {
+    private final Mapper mapper;
+
+    public ValueRangeConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    private void write(String str, long j, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedMember(ValueRange.class, str), Long.TYPE);
+        hierarchicalStreamWriter.setValue(String.valueOf(j));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls == ValueRange.class;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        ValueRange valueRange = (ValueRange) obj;
+        write("maxLargest", valueRange.getMaximum(), hierarchicalStreamWriter);
+        write("maxSmallest", valueRange.getSmallestMaximum(), hierarchicalStreamWriter);
+        write("minLargest", valueRange.getLargestMinimum(), hierarchicalStreamWriter);
+        write("minSmallest", valueRange.getMinimum(), hierarchicalStreamWriter);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        boolean equals = "custom".equals(hierarchicalStreamReader.getAttribute(this.mapper.aliasForSystemAttribute("serialization")));
+        if (equals) {
+            hierarchicalStreamReader.moveDown();
+            hierarchicalStreamReader.moveDown();
+        }
+        HashMap hashMap = new HashMap();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            if (!equals) {
+                nodeName = this.mapper.realMember(ValueRange.class, nodeName);
+            }
+            hashMap.put(nodeName, Long.valueOf(hierarchicalStreamReader.getValue()));
+            hierarchicalStreamReader.moveUp();
+        }
+        if (equals) {
+            hierarchicalStreamReader.moveUp();
+            hierarchicalStreamReader.moveUp();
+        }
+        return ValueRange.of(((Long) hashMap.get("minSmallest")).longValue(), ((Long) hashMap.get("minLargest")).longValue(), ((Long) hashMap.get("maxSmallest")).longValue(), ((Long) hashMap.get("maxLargest")).longValue());
+    }
+}

sources/com/thoughtworks/xstream/converters/time/WeekFieldsConverter.java

@@ -0,0 +1,66 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.time.DayOfWeek;
+import java.time.temporal.WeekFields;
+
+/* loaded from: classes.dex */
+public class WeekFieldsConverter implements Converter {
+    private final Mapper mapper;
+
+    public WeekFieldsConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls == WeekFields.class;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        WeekFields weekFields = (WeekFields) obj;
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedMember(WeekFields.class, "minimalDays"), Integer.TYPE);
+        hierarchicalStreamWriter.setValue(String.valueOf(weekFields.getMinimalDaysInFirstWeek()));
+        hierarchicalStreamWriter.endNode();
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedMember(WeekFields.class, "firstDayOfWeek"), DayOfWeek.class);
+        marshallingContext.convertAnother(weekFields.getFirstDayOfWeek());
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        boolean equals = "custom".equals(hierarchicalStreamReader.getAttribute(this.mapper.aliasForSystemAttribute("serialization")));
+        if (equals) {
+            hierarchicalStreamReader.moveDown();
+            hierarchicalStreamReader.moveDown();
+        }
+        DayOfWeek dayOfWeek = null;
+        int i = 0;
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = equals ? hierarchicalStreamReader.getNodeName() : this.mapper.realMember(WeekFields.class, hierarchicalStreamReader.getNodeName());
+            if ("minimalDays".equals(nodeName)) {
+                i = Integer.parseInt(hierarchicalStreamReader.getValue());
+            } else {
+                if (!"firstDayOfWeek".equals(nodeName)) {
+                    throw new AbstractReflectionConverter.UnknownFieldException(WeekFields.class.getName(), nodeName);
+                }
+                dayOfWeek = (DayOfWeek) unmarshallingContext.convertAnother(null, DayOfWeek.class);
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        if (equals) {
+            hierarchicalStreamReader.moveUp();
+            hierarchicalStreamReader.moveUp();
+        }
+        return WeekFields.of(dayOfWeek, i);
+    }
+}

sources/com/thoughtworks/xstream/converters/time/YearConverter.java

@@ -0,0 +1,24 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.Year;
+
+/* loaded from: classes.dex */
+public class YearConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return Year.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Year fromString(String str) {
+        try {
+            return Year.of(Integer.parseInt(str));
+        } catch (NumberFormatException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as year", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/YearMonthConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.time.YearMonth;
+import java.time.format.DateTimeParseException;
+
+/* loaded from: classes.dex */
+public class YearMonthConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return YearMonth.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public YearMonth fromString(String str) {
+        try {
+            return YearMonth.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as year month", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/ZoneIdConverter.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.DateTimeException;
+import java.time.ZoneId;
+import java.time.zone.ZoneRulesException;
+
+/* loaded from: classes.dex */
+public class ZoneIdConverter implements SingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && ZoneId.class.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return ((ZoneId) obj).getId();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public ZoneId fromString(String str) {
+        ConversionException conversionException;
+        try {
+            return ZoneId.of(str);
+        } catch (ZoneRulesException e) {
+            conversionException = new ConversionException("Not a valid zone id", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        } catch (DateTimeException e2) {
+            conversionException = new ConversionException("Cannot parse value as zone id", e2);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/time/ZonedDateTimeConverter.java

@@ -0,0 +1,38 @@
+package com.thoughtworks.xstream.converters.time;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoField;
+
+/* loaded from: classes.dex */
+public class ZonedDateTimeConverter implements SingleValueConverter {
+    private static final DateTimeFormatter FORMATTER = new DateTimeFormatterBuilder().appendPattern("uuuu-MM-dd'T'HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).appendOffsetId().appendLiteral("[").appendZoneId().appendLiteral("]").toFormatter();
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return ZonedDateTime.class == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return ZonedDateTime.parse(str);
+        } catch (DateTimeParseException e) {
+            ConversionException conversionException = new ConversionException("Cannot parse value as zoned date time", e);
+            conversionException.add("value", str);
+            throw conversionException;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return FORMATTER.format((ZonedDateTime) obj);
+    }
+}