Initial commit

sources/com/thoughtworks/xstream/InitializationException.java

@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream;
+
+import com.thoughtworks.xstream.XStream;
+
+/* loaded from: classes.dex */
+public class InitializationException extends XStream.InitializationException {
+    public InitializationException(String str, Throwable th) {
+        super(str, th);
+    }
+
+    public InitializationException(String str) {
+        super(str);
+    }
+}

sources/com/thoughtworks/xstream/MarshallingStrategy.java

@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream;
+
+import com.thoughtworks.xstream.converters.ConverterLookup;
+import com.thoughtworks.xstream.converters.DataHolder;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+public interface MarshallingStrategy {
+    void marshal(HierarchicalStreamWriter hierarchicalStreamWriter, Object obj, ConverterLookup converterLookup, Mapper mapper, DataHolder dataHolder);
+
+    Object unmarshal(Object obj, HierarchicalStreamReader hierarchicalStreamReader, DataHolder dataHolder, ConverterLookup converterLookup, Mapper mapper);
+}

sources/com/thoughtworks/xstream/XStreamException.java

@@ -0,0 +1,22 @@
+package com.thoughtworks.xstream;
+
+import com.thoughtworks.xstream.core.BaseException;
+
+/* loaded from: classes.dex */
+public class XStreamException extends BaseException {
+    protected XStreamException() {
+        this("", null);
+    }
+
+    public XStreamException(String str) {
+        this(str, null);
+    }
+
+    public XStreamException(Throwable th) {
+        this("", th);
+    }
+
+    public XStreamException(String str, Throwable th) {
+        super(str, th);
+    }
+}

sources/com/thoughtworks/xstream/XStreamer.java

@@ -0,0 +1,279 @@
+package com.thoughtworks.xstream;
+
+import com.thoughtworks.xstream.io.HierarchicalStreamDriver;
+import com.thoughtworks.xstream.io.StreamException;
+import com.thoughtworks.xstream.io.xml.XppDriver;
+import com.thoughtworks.xstream.security.TypeHierarchyPermission;
+import com.thoughtworks.xstream.security.TypePermission;
+import com.thoughtworks.xstream.security.WildcardTypePermission;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+
+/* loaded from: classes.dex */
+public class XStreamer {
+    private static final TypePermission[] PERMISSIONS;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$MarshallingStrategy;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$XStream;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$ConverterLookup;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$ConverterMatcher;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$ConverterRegistry;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$MarshallingContext;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$UnmarshallingContext;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$javabean$JavaBeanProvider;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$FieldKeySorter;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$core$JVM;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$io$HierarchicalStreamDriver;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$io$naming$NameCoder;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$TypePermission;
+    static /* synthetic */ Class class$javax$xml$datatype$DatatypeFactory;
+
+    static {
+        TypePermission[] typePermissionArr = new TypePermission[16];
+        Class cls = class$com$thoughtworks$xstream$converters$ConverterMatcher;
+        if (cls == null) {
+            cls = class$("com.thoughtworks.xstream.converters.ConverterMatcher");
+            class$com$thoughtworks$xstream$converters$ConverterMatcher = cls;
+        }
+        typePermissionArr[0] = new TypeHierarchyPermission(cls);
+        Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper;
+        if (cls2 == null) {
+            cls2 = class$("com.thoughtworks.xstream.mapper.Mapper");
+            class$com$thoughtworks$xstream$mapper$Mapper = cls2;
+        }
+        typePermissionArr[1] = new TypeHierarchyPermission(cls2);
+        Class cls3 = class$com$thoughtworks$xstream$XStream;
+        if (cls3 == null) {
+            cls3 = class$("com.thoughtworks.xstream.XStream");
+            class$com$thoughtworks$xstream$XStream = cls3;
+        }
+        typePermissionArr[2] = new TypeHierarchyPermission(cls3);
+        Class cls4 = class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider;
+        if (cls4 == null) {
+            cls4 = class$("com.thoughtworks.xstream.converters.reflection.ReflectionProvider");
+            class$com$thoughtworks$xstream$converters$reflection$ReflectionProvider = cls4;
+        }
+        typePermissionArr[3] = new TypeHierarchyPermission(cls4);
+        Class cls5 = class$com$thoughtworks$xstream$converters$javabean$JavaBeanProvider;
+        if (cls5 == null) {
+            cls5 = class$("com.thoughtworks.xstream.converters.javabean.JavaBeanProvider");
+            class$com$thoughtworks$xstream$converters$javabean$JavaBeanProvider = cls5;
+        }
+        typePermissionArr[4] = new TypeHierarchyPermission(cls5);
+        Class cls6 = class$com$thoughtworks$xstream$converters$reflection$FieldKeySorter;
+        if (cls6 == null) {
+            cls6 = class$("com.thoughtworks.xstream.converters.reflection.FieldKeySorter");
+            class$com$thoughtworks$xstream$converters$reflection$FieldKeySorter = cls6;
+        }
+        typePermissionArr[5] = new TypeHierarchyPermission(cls6);
+        Class cls7 = class$com$thoughtworks$xstream$converters$ConverterLookup;
+        if (cls7 == null) {
+            cls7 = class$("com.thoughtworks.xstream.converters.ConverterLookup");
+            class$com$thoughtworks$xstream$converters$ConverterLookup = cls7;
+        }
+        typePermissionArr[6] = new TypeHierarchyPermission(cls7);
+        Class cls8 = class$com$thoughtworks$xstream$converters$ConverterRegistry;
+        if (cls8 == null) {
+            cls8 = class$("com.thoughtworks.xstream.converters.ConverterRegistry");
+            class$com$thoughtworks$xstream$converters$ConverterRegistry = cls8;
+        }
+        typePermissionArr[7] = new TypeHierarchyPermission(cls8);
+        Class cls9 = class$com$thoughtworks$xstream$io$HierarchicalStreamDriver;
+        if (cls9 == null) {
+            cls9 = class$("com.thoughtworks.xstream.io.HierarchicalStreamDriver");
+            class$com$thoughtworks$xstream$io$HierarchicalStreamDriver = cls9;
+        }
+        typePermissionArr[8] = new TypeHierarchyPermission(cls9);
+        Class cls10 = class$com$thoughtworks$xstream$MarshallingStrategy;
+        if (cls10 == null) {
+            cls10 = class$("com.thoughtworks.xstream.MarshallingStrategy");
+            class$com$thoughtworks$xstream$MarshallingStrategy = cls10;
+        }
+        typePermissionArr[9] = new TypeHierarchyPermission(cls10);
+        Class cls11 = class$com$thoughtworks$xstream$converters$MarshallingContext;
+        if (cls11 == null) {
+            cls11 = class$("com.thoughtworks.xstream.converters.MarshallingContext");
+            class$com$thoughtworks$xstream$converters$MarshallingContext = cls11;
+        }
+        typePermissionArr[10] = new TypeHierarchyPermission(cls11);
+        Class cls12 = class$com$thoughtworks$xstream$converters$UnmarshallingContext;
+        if (cls12 == null) {
+            cls12 = class$("com.thoughtworks.xstream.converters.UnmarshallingContext");
+            class$com$thoughtworks$xstream$converters$UnmarshallingContext = cls12;
+        }
+        typePermissionArr[11] = new TypeHierarchyPermission(cls12);
+        Class cls13 = class$com$thoughtworks$xstream$io$naming$NameCoder;
+        if (cls13 == null) {
+            cls13 = class$("com.thoughtworks.xstream.io.naming.NameCoder");
+            class$com$thoughtworks$xstream$io$naming$NameCoder = cls13;
+        }
+        typePermissionArr[12] = new TypeHierarchyPermission(cls13);
+        Class cls14 = class$com$thoughtworks$xstream$security$TypePermission;
+        if (cls14 == null) {
+            cls14 = class$("com.thoughtworks.xstream.security.TypePermission");
+            class$com$thoughtworks$xstream$security$TypePermission = cls14;
+        }
+        typePermissionArr[13] = new TypeHierarchyPermission(cls14);
+        String[] strArr = new String[1];
+        StringBuffer stringBuffer = new StringBuffer();
+        Class cls15 = class$com$thoughtworks$xstream$core$JVM;
+        if (cls15 == null) {
+            cls15 = class$("com.thoughtworks.xstream.core.JVM");
+            class$com$thoughtworks$xstream$core$JVM = cls15;
+        }
+        stringBuffer.append(cls15.getPackage().getName());
+        stringBuffer.append(".**");
+        strArr[0] = stringBuffer.toString();
+        typePermissionArr[14] = new WildcardTypePermission(strArr);
+        Class cls16 = class$javax$xml$datatype$DatatypeFactory;
+        if (cls16 == null) {
+            cls16 = class$("javax.xml.datatype.DatatypeFactory");
+            class$javax$xml$datatype$DatatypeFactory = cls16;
+        }
+        typePermissionArr[15] = new TypeHierarchyPermission(cls16);
+        PERMISSIONS = typePermissionArr;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    public static TypePermission[] getDefaultPermissions() {
+        return (TypePermission[]) PERMISSIONS.clone();
+    }
+
+    public Object fromXML(String str) throws ClassNotFoundException, ObjectStreamException {
+        try {
+            return fromXML(new StringReader(str));
+        } catch (ObjectStreamException e) {
+            throw e;
+        } catch (IOException e2) {
+            throw new StreamException("Unexpected IO error from a StringReader", e2);
+        }
+    }
+
+    public String toXML(XStream xStream, Object obj) throws ObjectStreamException {
+        StringWriter stringWriter = new StringWriter();
+        try {
+            toXML(xStream, obj, stringWriter);
+            return stringWriter.toString();
+        } catch (ObjectStreamException e) {
+            throw e;
+        } catch (IOException e2) {
+            throw new StreamException("Unexpected IO error from a StringWriter", e2);
+        }
+    }
+
+    public Object fromXML(String str, TypePermission[] typePermissionArr) throws ClassNotFoundException, ObjectStreamException {
+        try {
+            return fromXML(new StringReader(str), typePermissionArr);
+        } catch (ObjectStreamException e) {
+            throw e;
+        } catch (IOException e2) {
+            throw new StreamException("Unexpected IO error from a StringReader", e2);
+        }
+    }
+
+    public void toXML(XStream xStream, Object obj, Writer writer) throws IOException {
+        XStream xStream2 = new XStream();
+        XStream.setupDefaultSecurity(xStream2);
+        ObjectOutputStream createObjectOutputStream = xStream2.createObjectOutputStream(writer);
+        try {
+            createObjectOutputStream.writeObject(xStream);
+            createObjectOutputStream.flush();
+            xStream.toXML(obj, writer);
+        } finally {
+            createObjectOutputStream.close();
+        }
+    }
+
+    public Object fromXML(HierarchicalStreamDriver hierarchicalStreamDriver, String str) throws ClassNotFoundException, ObjectStreamException {
+        try {
+            return fromXML(hierarchicalStreamDriver, new StringReader(str));
+        } catch (ObjectStreamException e) {
+            throw e;
+        } catch (IOException e2) {
+            throw new StreamException("Unexpected IO error from a StringReader", e2);
+        }
+    }
+
+    public Object fromXML(HierarchicalStreamDriver hierarchicalStreamDriver, String str, TypePermission[] typePermissionArr) throws ClassNotFoundException, ObjectStreamException {
+        try {
+            return fromXML(hierarchicalStreamDriver, new StringReader(str), typePermissionArr);
+        } catch (ObjectStreamException e) {
+            throw e;
+        } catch (IOException e2) {
+            throw new StreamException("Unexpected IO error from a StringReader", e2);
+        }
+    }
+
+    public Object fromXML(Reader reader) throws IOException, ClassNotFoundException {
+        return fromXML(new XppDriver(), reader);
+    }
+
+    public Object fromXML(Reader reader, TypePermission[] typePermissionArr) throws IOException, ClassNotFoundException {
+        return fromXML(new XppDriver(), reader, typePermissionArr);
+    }
+
+    public Object fromXML(HierarchicalStreamDriver hierarchicalStreamDriver, Reader reader) throws IOException, ClassNotFoundException {
+        return fromXML(hierarchicalStreamDriver, reader, PERMISSIONS);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:19:0x0036, code lost:
+    
+        r4 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:21:0x003a, code lost:
+    
+        throw r4;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public java.lang.Object fromXML(com.thoughtworks.xstream.io.HierarchicalStreamDriver r4, java.io.Reader r5, com.thoughtworks.xstream.security.TypePermission[] r6) throws java.io.IOException, java.lang.ClassNotFoundException {
+        /*
+            r3 = this;
+            com.thoughtworks.xstream.XStream r0 = new com.thoughtworks.xstream.XStream
+            r0.<init>(r4)
+            com.thoughtworks.xstream.XStream.setupDefaultSecurity(r0)
+            r1 = 0
+        L9:
+            int r2 = r6.length
+            if (r1 >= r2) goto L14
+            r2 = r6[r1]
+            r0.addPermission(r2)
+            int r1 = r1 + 1
+            goto L9
+        L14:
+            com.thoughtworks.xstream.io.HierarchicalStreamReader r4 = r4.createReader(r5)
+            java.io.ObjectInputStream r5 = r0.createObjectInputStream(r4)
+            java.lang.Object r6 = r5.readObject()     // Catch: java.lang.Throwable -> L36
+            com.thoughtworks.xstream.XStream r6 = (com.thoughtworks.xstream.XStream) r6     // Catch: java.lang.Throwable -> L36
+            java.io.ObjectInputStream r4 = r6.createObjectInputStream(r4)     // Catch: java.lang.Throwable -> L36
+            java.lang.Object r6 = r4.readObject()     // Catch: java.lang.Throwable -> L31
+            r4.close()     // Catch: java.lang.Throwable -> L36
+            r5.close()
+            return r6
+        L31:
+            r6 = move-exception
+            r4.close()     // Catch: java.lang.Throwable -> L36
+            throw r6     // Catch: java.lang.Throwable -> L36
+        L36:
+            r4 = move-exception
+            r5.close()
+            throw r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.XStreamer.fromXML(com.thoughtworks.xstream.io.HierarchicalStreamDriver, java.io.Reader, com.thoughtworks.xstream.security.TypePermission[]):java.lang.Object");
+    }
+}

sources/com/thoughtworks/xstream/annotations/AnnotationProvider.java

@@ -0,0 +1,13 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class AnnotationProvider {
+    @Deprecated
+    public <T extends Annotation> T getAnnotation(Field field, Class<T> cls) {
+        return (T) field.getAnnotation(cls);
+    }
+}

sources/com/thoughtworks/xstream/annotations/AnnotationReflectionConverter.java

@@ -0,0 +1,74 @@
+package com.thoughtworks.xstream.annotations;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.ConverterMatcher;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.SingleValueConverterWrapper;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import com.thoughtworks.xstream.converters.reflection.ReflectionConverter;
+import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class AnnotationReflectionConverter extends ReflectionConverter {
+    private final AnnotationProvider annotationProvider;
+    private final Map<Class<? extends ConverterMatcher>, Converter> cachedConverters;
+
+    @Deprecated
+    public AnnotationReflectionConverter(Mapper mapper, ReflectionProvider reflectionProvider, AnnotationProvider annotationProvider) {
+        super(mapper, reflectionProvider);
+        this.annotationProvider = annotationProvider;
+        this.cachedConverters = new HashMap();
+    }
+
+    private void ensureCache(Class<? extends ConverterMatcher> cls) {
+        if (this.cachedConverters.containsKey(cls)) {
+            return;
+        }
+        this.cachedConverters.put(cls, newInstance(cls));
+    }
+
+    private Converter newInstance(Class<? extends ConverterMatcher> cls) {
+        try {
+            return SingleValueConverter.class.isAssignableFrom(cls) ? new SingleValueConverterWrapper((SingleValueConverter) cls.getConstructor(new Class[0]).newInstance(new Object[0])) : (Converter) cls.getConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (IllegalAccessException e) {
+            throw new ObjectAccessException("Cannot construct " + cls.getName(), e);
+        } catch (InstantiationException e2) {
+            throw new ObjectAccessException("Cannot construct " + cls.getName(), e2);
+        } catch (NoSuchMethodException e3) {
+            throw new ObjectAccessException("Cannot construct " + cls.getName(), e3);
+        } catch (InvocationTargetException e4) {
+            throw new ObjectAccessException("Cannot construct " + cls.getName(), e4.getCause());
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
+    protected void marshallField(MarshallingContext marshallingContext, Object obj, Field field) {
+        XStreamConverter xStreamConverter = (XStreamConverter) this.annotationProvider.getAnnotation(field, XStreamConverter.class);
+        if (xStreamConverter == null) {
+            marshallingContext.convertAnother(obj);
+            return;
+        }
+        Class<? extends ConverterMatcher> value = xStreamConverter.value();
+        ensureCache(value);
+        marshallingContext.convertAnother(obj, this.cachedConverters.get(value));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
+    protected Object unmarshallField(UnmarshallingContext unmarshallingContext, Object obj, Class cls, Field field) {
+        XStreamConverter xStreamConverter = (XStreamConverter) this.annotationProvider.getAnnotation(field, XStreamConverter.class);
+        if (xStreamConverter == null) {
+            return unmarshallingContext.convertAnother(obj, cls);
+        }
+        Class<? extends ConverterMatcher> value = xStreamConverter.value();
+        ensureCache(value);
+        return unmarshallingContext.convertAnother(obj, cls, this.cachedConverters.get(value));
+    }
+}

sources/com/thoughtworks/xstream/annotations/Annotations.java

@@ -0,0 +1,17 @@
+package com.thoughtworks.xstream.annotations;
+
+import com.thoughtworks.xstream.XStream;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class Annotations {
+    private Annotations() {
+    }
+
+    @Deprecated
+    public static synchronized void configureAliases(XStream xStream, Class<?>... clsArr) {
+        synchronized (Annotations.class) {
+            xStream.processAnnotations(clsArr);
+        }
+    }
+}

sources/com/thoughtworks/xstream/annotations/XStreamAlias.java

@@ -0,0 +1,15 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamAlias {
+    Class<?> impl() default Void.class;
+
+    String value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamAliasType.java

@@ -0,0 +1,13 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamAliasType {
+    String value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamAsAttribute.java

@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamAsAttribute {
+}

sources/com/thoughtworks/xstream/annotations/XStreamContainedType.java

@@ -0,0 +1,13 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Deprecated
+/* loaded from: classes.dex */
+public @interface XStreamContainedType {
+}

sources/com/thoughtworks/xstream/annotations/XStreamConverter.java

@@ -0,0 +1,42 @@
+package com.thoughtworks.xstream.annotations;
+
+import com.thoughtworks.xstream.converters.ConverterMatcher;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamConverter {
+    boolean[] booleans() default {};
+
+    byte[] bytes() default {};
+
+    char[] chars() default {};
+
+    double[] doubles() default {};
+
+    float[] floats() default {};
+
+    int[] ints() default {};
+
+    long[] longs() default {};
+
+    Class<?>[] nulls() default {};
+
+    int priority() default 0;
+
+    short[] shorts() default {};
+
+    String[] strings() default {};
+
+    Class<?>[] types() default {};
+
+    boolean useImplicitType() default true;
+
+    Class<? extends ConverterMatcher> value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamConverters.java

@@ -0,0 +1,13 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamConverters {
+    XStreamConverter[] value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamImplicit.java

@@ -0,0 +1,15 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamImplicit {
+    String itemFieldName() default "";
+
+    String keyFieldName() default "";
+}

sources/com/thoughtworks/xstream/annotations/XStreamImplicitCollection.java

@@ -0,0 +1,15 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamImplicitCollection {
+    String item() default "";
+
+    String value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamInclude.java

@@ -0,0 +1,13 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamInclude {
+    Class<?>[] value();
+}

sources/com/thoughtworks/xstream/annotations/XStreamOmitField.java

@@ -0,0 +1,12 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface XStreamOmitField {
+}

sources/com/thoughtworks/xstream/converters/ConversionException.java

@@ -0,0 +1,16 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public class ConversionException extends ErrorWritingException {
+    public ConversionException(String str, Throwable th) {
+        super(str, th);
+    }
+
+    public ConversionException(String str) {
+        super(str);
+    }
+
+    public ConversionException(Throwable th) {
+        super(th);
+    }
+}

sources/com/thoughtworks/xstream/converters/Converter.java

@@ -0,0 +1,11 @@
+package com.thoughtworks.xstream.converters;
+
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public interface Converter extends ConverterMatcher {
+    void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext);
+
+    Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext);
+}

sources/com/thoughtworks/xstream/converters/ConverterLookup.java

@@ -0,0 +1,6 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface ConverterLookup {
+    Converter lookupConverterForType(Class cls);
+}

sources/com/thoughtworks/xstream/converters/ConverterMatcher.java

@@ -0,0 +1,6 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface ConverterMatcher {
+    boolean canConvert(Class cls);
+}

sources/com/thoughtworks/xstream/converters/ConverterRegistry.java

@@ -0,0 +1,6 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface ConverterRegistry {
+    void registerConverter(Converter converter, int i);
+}

sources/com/thoughtworks/xstream/converters/DataHolder.java

@@ -0,0 +1,12 @@
+package com.thoughtworks.xstream.converters;
+
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public interface DataHolder {
+    Object get(Object obj);
+
+    Iterator keys();
+
+    void put(Object obj, Object obj2);
+}

sources/com/thoughtworks/xstream/converters/ErrorReporter.java

@@ -0,0 +1,6 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface ErrorReporter {
+    void appendErrors(ErrorWriter errorWriter);
+}

sources/com/thoughtworks/xstream/converters/ErrorWriter.java

@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream.converters;
+
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public interface ErrorWriter {
+    void add(String str, String str2);
+
+    String get(String str);
+
+    Iterator keys();
+
+    void set(String str, String str2);
+}

sources/com/thoughtworks/xstream/converters/ErrorWritingException.java

@@ -0,0 +1,115 @@
+package com.thoughtworks.xstream.converters;
+
+import com.thoughtworks.xstream.XStreamException;
+import com.thoughtworks.xstream.core.util.OrderRetainingMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class ErrorWritingException extends XStreamException implements ErrorWriter {
+    private static final String SEPARATOR = "\n-------------------------------";
+    private final Map stuff;
+
+    public ErrorWritingException(String str) {
+        super(str);
+        this.stuff = new OrderRetainingMap();
+        addData(str, null);
+    }
+
+    private void addData(String str, Throwable th) {
+        if (str != null) {
+            add("message", str);
+        }
+        if (th != null) {
+            add("cause-exception", th.getClass().getName());
+            add("cause-message", th instanceof ErrorWritingException ? ((ErrorWritingException) th).getShortMessage() : th.getMessage());
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorWriter
+    public void add(String str, String str2) {
+        String str3 = str;
+        int i = 0;
+        while (this.stuff.containsKey(str3)) {
+            if (str2.equals((String) this.stuff.get(str3))) {
+                return;
+            }
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(str);
+            stringBuffer.append("[");
+            i++;
+            stringBuffer.append(i);
+            stringBuffer.append("]");
+            str3 = stringBuffer.toString();
+        }
+        this.stuff.put(str3, str2);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorWriter
+    public String get(String str) {
+        return (String) this.stuff.get(str);
+    }
+
+    @Override // java.lang.Throwable
+    public String getMessage() {
+        StringBuffer stringBuffer = new StringBuffer();
+        if (super.getMessage() != null) {
+            stringBuffer.append(super.getMessage());
+        }
+        if (!stringBuffer.toString().endsWith(SEPARATOR)) {
+            stringBuffer.append("\n---- Debugging information ----");
+        }
+        Iterator keys = keys();
+        while (keys.hasNext()) {
+            String str = (String) keys.next();
+            String str2 = get(str);
+            stringBuffer.append('\n');
+            stringBuffer.append(str);
+            stringBuffer.append("                    ".substring(Math.min(20, str.length())));
+            stringBuffer.append(": ");
+            stringBuffer.append(str2);
+        }
+        stringBuffer.append(SEPARATOR);
+        return stringBuffer.toString();
+    }
+
+    public String getShortMessage() {
+        return super.getMessage();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorWriter
+    public Iterator keys() {
+        return this.stuff.keySet().iterator();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorWriter
+    public void set(String str, String str2) {
+        this.stuff.put(str, str2);
+        String str3 = str;
+        int i = 0;
+        while (this.stuff.containsKey(str3)) {
+            if (i != 0) {
+                this.stuff.remove(str3);
+            }
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(str);
+            stringBuffer.append("[");
+            i++;
+            stringBuffer.append(i);
+            stringBuffer.append("]");
+            str3 = stringBuffer.toString();
+        }
+    }
+
+    public ErrorWritingException(Throwable th) {
+        super(th);
+        this.stuff = new OrderRetainingMap();
+        addData(null, th);
+    }
+
+    public ErrorWritingException(String str, Throwable th) {
+        super(str, th);
+        this.stuff = new OrderRetainingMap();
+        addData(str, th);
+    }
+}

sources/com/thoughtworks/xstream/converters/MarshallingContext.java

@@ -0,0 +1,8 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface MarshallingContext extends DataHolder {
+    void convertAnother(Object obj);
+
+    void convertAnother(Object obj, Converter converter);
+}

sources/com/thoughtworks/xstream/converters/SingleValueConverter.java

@@ -0,0 +1,8 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface SingleValueConverter extends ConverterMatcher {
+    Object fromString(String str);
+
+    String toString(Object obj);
+}

sources/com/thoughtworks/xstream/converters/SingleValueConverterWrapper.java

@@ -0,0 +1,48 @@
+package com.thoughtworks.xstream.converters;
+
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public class SingleValueConverterWrapper implements Converter, SingleValueConverter, ErrorReporter {
+    private final SingleValueConverter wrapped;
+
+    public SingleValueConverterWrapper(SingleValueConverter singleValueConverter) {
+        this.wrapped = singleValueConverter;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorReporter
+    public void appendErrors(ErrorWriter errorWriter) {
+        SingleValueConverter singleValueConverter = this.wrapped;
+        errorWriter.add("wrapped-converter", singleValueConverter == null ? "(null)" : singleValueConverter.getClass().getName());
+        SingleValueConverter singleValueConverter2 = this.wrapped;
+        if (singleValueConverter2 instanceof ErrorReporter) {
+            ((ErrorReporter) singleValueConverter2).appendErrors(errorWriter);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return this.wrapped.canConvert(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.wrapped.fromString(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.setValue(toString(obj));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return this.wrapped.toString(obj);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return fromString(hierarchicalStreamReader.getValue());
+    }
+}

sources/com/thoughtworks/xstream/converters/UnmarshallingContext.java

@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream.converters;
+
+/* loaded from: classes.dex */
+public interface UnmarshallingContext extends DataHolder {
+    void addCompletionCallback(Runnable runnable, int i);
+
+    Object convertAnother(Object obj, Class cls);
+
+    Object convertAnother(Object obj, Class cls, Converter converter);
+
+    Object currentObject();
+
+    Class getRequiredType();
+}

sources/com/thoughtworks/xstream/converters/basic/AbstractSingleValueConverter.java

@@ -0,0 +1,20 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+
+/* loaded from: classes.dex */
+public abstract class AbstractSingleValueConverter implements SingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public abstract boolean canConvert(Class cls);
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public abstract Object fromString(String str);
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return obj.toString();
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/BigDecimalConverter.java

@@ -0,0 +1,31 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import java.math.BigDecimal;
+
+/* loaded from: classes.dex */
+public class BigDecimalConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$math$BigDecimal;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$math$BigDecimal;
+        if (cls2 == null) {
+            cls2 = class$("java.math.BigDecimal");
+            class$java$math$BigDecimal = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return new BigDecimal(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/BigIntegerConverter.java

@@ -0,0 +1,31 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import java.math.BigInteger;
+
+/* loaded from: classes.dex */
+public class BigIntegerConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$math$BigInteger;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$math$BigInteger;
+        if (cls2 == null) {
+            cls2 = class$("java.math.BigInteger");
+            class$java$math$BigInteger = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return new BigInteger(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/BooleanConverter.java

@@ -0,0 +1,65 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.tencent.bugly.Bugly;
+
+/* loaded from: classes.dex */
+public class BooleanConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Boolean;
+    private final boolean caseSensitive;
+    private final String negative;
+    private final String positive;
+    public static final BooleanConverter TRUE_FALSE = new BooleanConverter("true", Bugly.SDK_IS_DEV, false);
+    public static final BooleanConverter YES_NO = new BooleanConverter("yes", "no", false);
+    public static final BooleanConverter BINARY = new BooleanConverter("1", "0", true);
+
+    public BooleanConverter(String str, String str2, boolean z) {
+        this.positive = str;
+        this.negative = str2;
+        this.caseSensitive = z;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Boolean.TYPE) {
+            Class cls2 = class$java$lang$Boolean;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Boolean");
+                class$java$lang$Boolean = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.caseSensitive ? this.positive.equals(str) ? Boolean.TRUE : Boolean.FALSE : this.positive.equalsIgnoreCase(str) ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    public boolean shouldConvert(Class cls, Object obj) {
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Boolean bool = (Boolean) obj;
+        if (obj == null) {
+            return null;
+        }
+        return bool.booleanValue() ? this.positive : this.negative;
+    }
+
+    public BooleanConverter() {
+        this("true", Bugly.SDK_IS_DEV, false);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/ByteConverter.java

@@ -0,0 +1,42 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class ByteConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Byte;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Byte.TYPE) {
+            Class cls2 = class$java$lang$Byte;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Byte");
+                class$java$lang$Byte = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        int intValue = Integer.decode(str).intValue();
+        if (intValue >= -128 && intValue <= 255) {
+            return new Byte((byte) intValue);
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("For input string: \"");
+        stringBuffer.append(str);
+        stringBuffer.append('\"');
+        throw new NumberFormatException(stringBuffer.toString());
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/CharConverter.java

@@ -0,0 +1,57 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public class CharConverter implements Converter, SingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Character;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Character.TYPE) {
+            Class cls2 = class$java$lang$Character;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Character");
+                class$java$lang$Character = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return str.length() == 0 ? new Character((char) 0) : new Character(str.charAt(0));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.setValue(toString(obj));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return ((Character) obj).charValue() == 0 ? "" : obj.toString();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String attribute = hierarchicalStreamReader.getAttribute("null");
+        return (attribute == null || !attribute.equals("true")) ? fromString(hierarchicalStreamReader.getValue()) : new Character((char) 0);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/DateConverter.java

@@ -0,0 +1,178 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.ErrorReporter;
+import com.thoughtworks.xstream.converters.ErrorWriter;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.ThreadSafeSimpleDateFormat;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/* loaded from: classes.dex */
+public class DateConverter extends AbstractSingleValueConverter implements ErrorReporter {
+    private static final String[] DEFAULT_ACCEPTABLE_FORMATS;
+    private static final String DEFAULT_ERA_PATTERN;
+    private static final String DEFAULT_PATTERN;
+    private static final long ERA_START;
+    private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
+    static /* synthetic */ Class class$java$util$Date;
+    private final ThreadSafeSimpleDateFormat[] acceptableFormats;
+    private final ThreadSafeSimpleDateFormat defaultEraFormat;
+    private final ThreadSafeSimpleDateFormat defaultFormat;
+
+    static {
+        ArrayList arrayList = new ArrayList();
+        boolean canParseUTCDateFormat = JVM.canParseUTCDateFormat();
+        DEFAULT_PATTERN = canParseUTCDateFormat ? "yyyy-MM-dd HH:mm:ss.S z" : "yyyy-MM-dd HH:mm:ss.S 'UTC'";
+        DEFAULT_ERA_PATTERN = canParseUTCDateFormat ? "yyyy-MM-dd G HH:mm:ss.S z" : "yyyy-MM-dd G HH:mm:ss.S 'UTC'";
+        arrayList.add("yyyy-MM-dd HH:mm:ss.S z");
+        if (!canParseUTCDateFormat) {
+            arrayList.add("yyyy-MM-dd HH:mm:ss.S z");
+        }
+        arrayList.add("yyyy-MM-dd HH:mm:ss.S a");
+        arrayList.add("yyyy-MM-dd HH:mm:ssz");
+        arrayList.add("yyyy-MM-dd HH:mm:ss z");
+        if (!canParseUTCDateFormat) {
+            arrayList.add("yyyy-MM-dd HH:mm:ss 'UTC'");
+        }
+        if (JVM.canParseISO8601TimeZoneInDateFormat()) {
+            arrayList.add("yyyy-MM-dd'T'HH:mm:ss.SX");
+            arrayList.add("yyyy-MM-dd'T'HH:mm:ssX");
+            arrayList.add("yyyy-MM-dd'T'HH:mmX");
+        }
+        arrayList.add("yyyy-MM-dd HH:mm:ssa");
+        DEFAULT_ACCEPTABLE_FORMATS = (String[]) arrayList.toArray(new String[arrayList.size()]);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(UTC);
+        calendar.clear();
+        calendar.set(1, 0, 1);
+        ERA_START = calendar.getTime().getTime();
+    }
+
+    public DateConverter() {
+        this(false);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ErrorReporter
+    public void appendErrors(ErrorWriter errorWriter) {
+        errorWriter.add("Default date pattern", this.defaultFormat.toString());
+        ThreadSafeSimpleDateFormat threadSafeSimpleDateFormat = this.defaultEraFormat;
+        if (threadSafeSimpleDateFormat != null) {
+            errorWriter.add("Default era date pattern", threadSafeSimpleDateFormat.toString());
+        }
+        int i = 0;
+        while (true) {
+            ThreadSafeSimpleDateFormat[] threadSafeSimpleDateFormatArr = this.acceptableFormats;
+            if (i >= threadSafeSimpleDateFormatArr.length) {
+                return;
+            }
+            errorWriter.add("Alternative date pattern", threadSafeSimpleDateFormatArr[i].toString());
+            i++;
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$Date;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Date");
+            class$java$util$Date = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        ThreadSafeSimpleDateFormat threadSafeSimpleDateFormat = this.defaultEraFormat;
+        if (threadSafeSimpleDateFormat != null) {
+            try {
+                return threadSafeSimpleDateFormat.parse(str);
+            } catch (ParseException unused) {
+            }
+        }
+        ThreadSafeSimpleDateFormat threadSafeSimpleDateFormat2 = this.defaultEraFormat;
+        ThreadSafeSimpleDateFormat threadSafeSimpleDateFormat3 = this.defaultFormat;
+        if (threadSafeSimpleDateFormat2 != threadSafeSimpleDateFormat3) {
+            try {
+                return threadSafeSimpleDateFormat3.parse(str);
+            } catch (ParseException unused2) {
+            }
+        }
+        int i = 0;
+        while (true) {
+            ThreadSafeSimpleDateFormat[] threadSafeSimpleDateFormatArr = this.acceptableFormats;
+            if (i >= threadSafeSimpleDateFormatArr.length) {
+                ConversionException conversionException = new ConversionException("Cannot parse date");
+                conversionException.add("date", str);
+                throw conversionException;
+            }
+            try {
+                return threadSafeSimpleDateFormatArr[i].parse(str);
+            } catch (ParseException unused3) {
+                i++;
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        ThreadSafeSimpleDateFormat threadSafeSimpleDateFormat;
+        Date date = (Date) obj;
+        return (date.getTime() >= ERA_START || (threadSafeSimpleDateFormat = this.defaultEraFormat) == null) ? this.defaultFormat.format(date) : threadSafeSimpleDateFormat.format(date);
+    }
+
+    public DateConverter(TimeZone timeZone) {
+        this(DEFAULT_PATTERN, DEFAULT_ACCEPTABLE_FORMATS, timeZone);
+    }
+
+    public DateConverter(boolean z) {
+        this(DEFAULT_PATTERN, DEFAULT_ACCEPTABLE_FORMATS, z);
+    }
+
+    public DateConverter(String str, String[] strArr) {
+        this(str, strArr, false);
+    }
+
+    public DateConverter(String str, String[] strArr, TimeZone timeZone) {
+        this(str, strArr, timeZone, false);
+    }
+
+    public DateConverter(String str, String[] strArr, boolean z) {
+        this(str, strArr, UTC, z);
+    }
+
+    public DateConverter(String str, String[] strArr, TimeZone timeZone, boolean z) {
+        this(DEFAULT_ERA_PATTERN, str, strArr, Locale.ENGLISH, timeZone, z);
+    }
+
+    public DateConverter(String str, String str2, String[] strArr, Locale locale, TimeZone timeZone, boolean z) {
+        if (str != null) {
+            this.defaultEraFormat = new ThreadSafeSimpleDateFormat(str, timeZone, locale, 4, 20, z);
+        } else {
+            this.defaultEraFormat = null;
+        }
+        this.defaultFormat = new ThreadSafeSimpleDateFormat(str2, timeZone, locale, 4, 20, z);
+        int i = 0;
+        this.acceptableFormats = strArr != null ? new ThreadSafeSimpleDateFormat[strArr.length] : new ThreadSafeSimpleDateFormat[0];
+        while (true) {
+            ThreadSafeSimpleDateFormat[] threadSafeSimpleDateFormatArr = this.acceptableFormats;
+            if (i >= threadSafeSimpleDateFormatArr.length) {
+                return;
+            }
+            threadSafeSimpleDateFormatArr[i] = new ThreadSafeSimpleDateFormat(strArr[i], timeZone, locale, 1, 20, z);
+            i++;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/DoubleConverter.java

@@ -0,0 +1,34 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class DoubleConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Double;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Double.TYPE) {
+            Class cls2 = class$java$lang$Double;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Double");
+                class$java$lang$Double = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Double.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/FloatConverter.java

@@ -0,0 +1,34 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class FloatConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Float;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Float.TYPE) {
+            Class cls2 = class$java$lang$Float;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Float");
+                class$java$lang$Float = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Float.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/IntConverter.java

@@ -0,0 +1,42 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class IntConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Integer;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Integer.TYPE) {
+            Class cls2 = class$java$lang$Integer;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Integer");
+                class$java$lang$Integer = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        long longValue = Long.decode(str).longValue();
+        if (longValue >= -2147483648L && longValue <= 4294967295L) {
+            return new Integer((int) longValue);
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("For input string: \"");
+        stringBuffer.append(str);
+        stringBuffer.append('\"');
+        throw new NumberFormatException(stringBuffer.toString());
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/LongConverter.java

@@ -0,0 +1,63 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class LongConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Long;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Long.TYPE) {
+            Class cls2 = class$java$lang$Long;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Long");
+                class$java$lang$Long = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        long parseLong;
+        long j;
+        int length = str.length();
+        if (length == 0) {
+            throw new NumberFormatException("For input string: \"\"");
+        }
+        if (length < 17) {
+            return Long.decode(str);
+        }
+        char charAt = str.charAt(0);
+        if (charAt != '0' && charAt != '#') {
+            return Long.decode(str);
+        }
+        char charAt2 = str.charAt(1);
+        if (charAt == '#' && length == 17) {
+            j = Long.parseLong(str.substring(1, 9), 16) << 32;
+            parseLong = Long.parseLong(str.substring(9, 17), 16);
+        } else if ((charAt2 == 'x' || charAt2 == 'X') && length == 18) {
+            long parseLong2 = Long.parseLong(str.substring(2, 10), 16) << 32;
+            parseLong = Long.parseLong(str.substring(10, 18), 16);
+            j = parseLong2;
+        } else {
+            if (length != 23 || charAt2 != '1') {
+                return Long.decode(str);
+            }
+            long parseLong3 = Long.parseLong(str.substring(1, 12), 8) << 33;
+            parseLong = Long.parseLong(str.substring(12, 23), 8);
+            j = parseLong3;
+        }
+        return new Long(parseLong | j);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/NullConverter.java

@@ -0,0 +1,52 @@
+package com.thoughtworks.xstream.converters.basic;
+
+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;
+
+/* loaded from: classes.dex */
+public class NullConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+            }
+            if (!cls2.isAssignableFrom(cls)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Class cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+        if (cls == null) {
+            cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "null", cls);
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return null;
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/ShortConverter.java

@@ -0,0 +1,42 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class ShortConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Short;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != Short.TYPE) {
+            Class cls2 = class$java$lang$Short;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Short");
+                class$java$lang$Short = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        int intValue = Integer.decode(str).intValue();
+        if (intValue >= -32768 && intValue <= 65535) {
+            return new Short((short) intValue);
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("For input string: \"");
+        stringBuffer.append(str);
+        stringBuffer.append('\"');
+        throw new NumberFormatException(stringBuffer.toString());
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/StringBufferConverter.java

@@ -0,0 +1,29 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class StringBufferConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$StringBuffer;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$StringBuffer;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.StringBuffer");
+            class$java$lang$StringBuffer = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return new StringBuffer(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/StringBuilderConverter.java

@@ -0,0 +1,29 @@
+package com.thoughtworks.xstream.converters.basic;
+
+/* loaded from: classes.dex */
+public class StringBuilderConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$StringBuilder;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$StringBuilder;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.StringBuilder");
+            class$java$lang$StringBuilder = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return new StringBuilder(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/StringConverter.java

@@ -0,0 +1,64 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.core.util.WeakCache;
+import java.util.Collections;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class StringConverter extends AbstractSingleValueConverter {
+    private static final int LENGTH_LIMIT = 38;
+    static /* synthetic */ Class class$java$lang$String;
+    private final Map cache;
+    private final int lengthLimit;
+
+    public StringConverter(Map map, int i) {
+        this.cache = map;
+        this.lengthLimit = i;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$String;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.String");
+            class$java$lang$String = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        if (this.cache == null || str == null) {
+            return str;
+        }
+        if (this.lengthLimit >= 0 && str.length() > this.lengthLimit) {
+            return str;
+        }
+        String str2 = (String) this.cache.get(str);
+        if (str2 != null) {
+            return str2;
+        }
+        this.cache.put(str, str);
+        return str;
+    }
+
+    public StringConverter(Map map) {
+        this(map, 38);
+    }
+
+    public StringConverter(int i) {
+        this(Collections.synchronizedMap(new WeakCache()), i);
+    }
+
+    public StringConverter() {
+        this(38);
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/URIConverter.java

@@ -0,0 +1,37 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/* loaded from: classes.dex */
+public class URIConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$net$URI;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$net$URI;
+        if (cls2 == null) {
+            cls2 = class$("java.net.URI");
+            class$java$net$URI = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return new URI(str);
+        } catch (URISyntaxException e) {
+            throw new ConversionException(e);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/URLConverter.java

@@ -0,0 +1,37 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/* loaded from: classes.dex */
+public class URLConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$net$URL;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$net$URL;
+        if (cls2 == null) {
+            cls2 = class$("java.net.URL");
+            class$java$net$URL = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return new URL(str);
+        } catch (MalformedURLException e) {
+            throw new ConversionException(e);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/basic/UUIDConverter.java

@@ -0,0 +1,36 @@
+package com.thoughtworks.xstream.converters.basic;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import java.util.UUID;
+
+/* loaded from: classes.dex */
+public class UUIDConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$util$UUID;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$UUID;
+        if (cls2 == null) {
+            cls2 = class$("java.util.UUID");
+            class$java$util$UUID = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return UUID.fromString(str);
+        } catch (IllegalArgumentException e) {
+            throw new ConversionException("Cannot create UUID instance", e);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/AbstractCollectionConverter.java

@@ -0,0 +1,106 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.ErrorWritingException;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+public abstract class AbstractCollectionConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    private final Mapper mapper;
+
+    public AbstractCollectionConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public abstract boolean canConvert(Class cls);
+
+    protected Object createCollection(Class cls) {
+        ErrorWritingException conversionException;
+        Class defaultImplementationOf = mapper().defaultImplementationOf(cls);
+        try {
+            return defaultImplementationOf.newInstance();
+        } catch (IllegalAccessException e) {
+            conversionException = new ObjectAccessException("Cannot instantiate default collection", e);
+            conversionException.add("collection-type", cls.getName());
+            conversionException.add("default-type", defaultImplementationOf.getName());
+            throw conversionException;
+        } catch (InstantiationException e2) {
+            conversionException = new ConversionException("Cannot instantiate default collection", e2);
+            conversionException.add("collection-type", cls.getName());
+            conversionException.add("default-type", defaultImplementationOf.getName());
+            throw conversionException;
+        }
+    }
+
+    protected Mapper mapper() {
+        return this.mapper;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public abstract void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext);
+
+    protected Object readBareItem(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Object obj) {
+        return unmarshallingContext.convertAnother(obj, HierarchicalStreams.readClassType(hierarchicalStreamReader, mapper()));
+    }
+
+    protected Object readCompleteItem(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Object obj) {
+        hierarchicalStreamReader.moveDown();
+        Object readItem = readItem(hierarchicalStreamReader, unmarshallingContext, obj);
+        hierarchicalStreamReader.moveUp();
+        return readItem;
+    }
+
+    protected Object readItem(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Object obj) {
+        return readBareItem(hierarchicalStreamReader, unmarshallingContext, obj);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public abstract Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext);
+
+    protected void writeBareItem(Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        marshallingContext.convertAnother(obj);
+    }
+
+    protected void writeCompleteItem(Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        writeItem(obj, marshallingContext, hierarchicalStreamWriter);
+    }
+
+    protected void writeItem(Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        if (obj == null) {
+            writeNullItem(marshallingContext, hierarchicalStreamWriter);
+            return;
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, mapper().serializedClass(obj.getClass()), obj.getClass());
+        writeBareItem(obj, marshallingContext, hierarchicalStreamWriter);
+        hierarchicalStreamWriter.endNode();
+    }
+
+    protected void writeNullItem(MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        String serializedClass = mapper().serializedClass(null);
+        Class cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+        if (cls == null) {
+            cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, serializedClass, cls);
+        hierarchicalStreamWriter.endNode();
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/ArrayConverter.java

@@ -0,0 +1,46 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class ArrayConverter extends AbstractCollectionConverter {
+    public ArrayConverter(Mapper mapper) {
+        super(mapper);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && cls.isArray();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        int length = Array.getLength(obj);
+        for (int i = 0; i < length; i++) {
+            writeCompleteItem(Array.get(obj, i), marshallingContext, hierarchicalStreamWriter);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        ArrayList arrayList = new ArrayList();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            arrayList.add(readCompleteItem(hierarchicalStreamReader, unmarshallingContext, null));
+        }
+        Object newInstance = Array.newInstance(unmarshallingContext.getRequiredType().getComponentType(), arrayList.size());
+        int i = 0;
+        Iterator it = arrayList.iterator();
+        while (it.hasNext()) {
+            Array.set(newInstance, i, it.next());
+            i++;
+        }
+        return newInstance;
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/BitSetConverter.java

@@ -0,0 +1,60 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import java.util.BitSet;
+import java.util.StringTokenizer;
+
+/* loaded from: classes.dex */
+public class BitSetConverter implements Converter {
+    static /* synthetic */ Class class$java$util$BitSet;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$BitSet;
+        if (cls2 == null) {
+            cls2 = class$("java.util.BitSet");
+            class$java$util$BitSet = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        BitSet bitSet = (BitSet) obj;
+        StringBuffer stringBuffer = new StringBuffer();
+        boolean z = false;
+        for (int i = 0; i < bitSet.length(); i++) {
+            if (bitSet.get(i)) {
+                if (z) {
+                    stringBuffer.append(',');
+                } else {
+                    z = true;
+                }
+                stringBuffer.append(i);
+            }
+        }
+        hierarchicalStreamWriter.setValue(stringBuffer.toString());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        BitSet bitSet = new BitSet();
+        StringTokenizer stringTokenizer = new StringTokenizer(hierarchicalStreamReader.getValue(), ",", false);
+        while (stringTokenizer.hasMoreTokens()) {
+            bitSet.set(Integer.parseInt(stringTokenizer.nextToken()));
+        }
+        return bitSet;
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/CharArrayConverter.java

@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public class CharArrayConverter implements Converter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && cls.isArray() && cls.getComponentType().equals(Character.TYPE);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.setValue(new String((char[]) obj));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return hierarchicalStreamReader.getValue().toCharArray();
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/CollectionConverter.java

@@ -0,0 +1,142 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.util.Collection;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class CollectionConverter extends AbstractCollectionConverter {
+    static /* synthetic */ Class class$java$util$ArrayList;
+    static /* synthetic */ Class class$java$util$Collection;
+    static /* synthetic */ Class class$java$util$HashSet;
+    static /* synthetic */ Class class$java$util$LinkedHashSet;
+    static /* synthetic */ Class class$java$util$LinkedList;
+    static /* synthetic */ Class class$java$util$Vector;
+    private final Class type;
+
+    public CollectionConverter(Mapper mapper) {
+        this(mapper, null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    protected void addCurrentElementToCollection(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Collection collection, Collection collection2) {
+        collection2.add(readItem(hierarchicalStreamReader, unmarshallingContext, collection));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Object obj = this.type;
+        if (obj != null) {
+            return cls.equals(obj);
+        }
+        Class cls2 = class$java$util$ArrayList;
+        if (cls2 == null) {
+            cls2 = class$("java.util.ArrayList");
+            class$java$util$ArrayList = cls2;
+        }
+        if (!cls.equals(cls2)) {
+            Class cls3 = class$java$util$HashSet;
+            if (cls3 == null) {
+                cls3 = class$("java.util.HashSet");
+                class$java$util$HashSet = cls3;
+            }
+            if (!cls.equals(cls3)) {
+                Class cls4 = class$java$util$LinkedList;
+                if (cls4 == null) {
+                    cls4 = class$("java.util.LinkedList");
+                    class$java$util$LinkedList = cls4;
+                }
+                if (!cls.equals(cls4)) {
+                    Class cls5 = class$java$util$Vector;
+                    if (cls5 == null) {
+                        cls5 = class$("java.util.Vector");
+                        class$java$util$Vector = cls5;
+                    }
+                    if (!cls.equals(cls5)) {
+                        Class cls6 = class$java$util$LinkedHashSet;
+                        if (cls6 == null) {
+                            cls6 = class$("java.util.LinkedHashSet");
+                            class$java$util$LinkedHashSet = cls6;
+                        }
+                        if (!cls.equals(cls6)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter
+    protected Object createCollection(Class cls) {
+        Class cls2 = this.type;
+        if (cls2 != null) {
+            cls = cls2;
+        }
+        return super.createCollection(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Iterator it = ((Collection) obj).iterator();
+        while (it.hasNext()) {
+            writeCompleteItem(it.next(), marshallingContext, hierarchicalStreamWriter);
+        }
+    }
+
+    protected void populateCollection(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Collection collection) {
+        populateCollection(hierarchicalStreamReader, unmarshallingContext, collection, collection);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Collection collection = (Collection) createCollection(unmarshallingContext.getRequiredType());
+        populateCollection(hierarchicalStreamReader, unmarshallingContext, collection);
+        return collection;
+    }
+
+    public CollectionConverter(Mapper mapper, Class cls) {
+        super(mapper);
+        this.type = cls;
+        if (cls != null) {
+            Class cls2 = class$java$util$Collection;
+            if (cls2 == null) {
+                cls2 = class$("java.util.Collection");
+                class$java$util$Collection = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return;
+            }
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(cls);
+            stringBuffer.append(" not of type ");
+            Class cls3 = class$java$util$Collection;
+            if (cls3 == null) {
+                cls3 = class$("java.util.Collection");
+                class$java$util$Collection = cls3;
+            }
+            stringBuffer.append(cls3);
+            throw new IllegalArgumentException(stringBuffer.toString());
+        }
+    }
+
+    protected void populateCollection(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Collection collection, Collection collection2) {
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            addCurrentElementToCollection(hierarchicalStreamReader, unmarshallingContext, collection, collection2);
+            hierarchicalStreamReader.moveUp();
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/MapConverter.java

@@ -0,0 +1,129 @@
+package com.thoughtworks.xstream.converters.collections;
+
+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.util.Map;
+
+/* loaded from: classes.dex */
+public class MapConverter extends AbstractCollectionConverter {
+    static /* synthetic */ Class class$java$util$HashMap;
+    static /* synthetic */ Class class$java$util$Hashtable;
+    static /* synthetic */ Class class$java$util$Map;
+    static /* synthetic */ Class class$java$util$Map$Entry;
+    private final Class type;
+
+    public MapConverter(Mapper mapper) {
+        this(mapper, null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Object obj = this.type;
+        if (obj != null) {
+            return cls.equals(obj);
+        }
+        Class cls2 = class$java$util$HashMap;
+        if (cls2 == null) {
+            cls2 = class$("java.util.HashMap");
+            class$java$util$HashMap = cls2;
+        }
+        if (!cls.equals(cls2)) {
+            Class cls3 = class$java$util$Hashtable;
+            if (cls3 == null) {
+                cls3 = class$("java.util.Hashtable");
+                class$java$util$Hashtable = cls3;
+            }
+            if (!cls.equals(cls3) && !cls.getName().equals("java.util.LinkedHashMap") && !cls.getName().equals("java.util.concurrent.ConcurrentHashMap") && !cls.getName().equals("sun.font.AttributeMap")) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter
+    protected Object createCollection(Class cls) {
+        Class cls2 = this.type;
+        if (cls2 != null) {
+            cls = cls2;
+        }
+        return super.createCollection(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Map map = (Map) obj;
+        Mapper mapper = mapper();
+        Class cls = class$java$util$Map$Entry;
+        if (cls == null) {
+            cls = class$("java.util.Map$Entry");
+            class$java$util$Map$Entry = cls;
+        }
+        String serializedClass = mapper.serializedClass(cls);
+        for (Map.Entry entry : map.entrySet()) {
+            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, serializedClass, entry.getClass());
+            writeCompleteItem(entry.getKey(), marshallingContext, hierarchicalStreamWriter);
+            writeCompleteItem(entry.getValue(), marshallingContext, hierarchicalStreamWriter);
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    protected void populateMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map) {
+        populateMap(hierarchicalStreamReader, unmarshallingContext, map, map);
+    }
+
+    protected void putCurrentEntryIntoMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map, Map map2) {
+        map2.put(readCompleteItem(hierarchicalStreamReader, unmarshallingContext, map), readCompleteItem(hierarchicalStreamReader, unmarshallingContext, map));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Map map = (Map) createCollection(unmarshallingContext.getRequiredType());
+        populateMap(hierarchicalStreamReader, unmarshallingContext, map);
+        return map;
+    }
+
+    public MapConverter(Mapper mapper, Class cls) {
+        super(mapper);
+        this.type = cls;
+        if (cls != null) {
+            Class cls2 = class$java$util$Map;
+            if (cls2 == null) {
+                cls2 = class$("java.util.Map");
+                class$java$util$Map = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return;
+            }
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(cls);
+            stringBuffer.append(" not of type ");
+            Class cls3 = class$java$util$Map;
+            if (cls3 == null) {
+                cls3 = class$("java.util.Map");
+                class$java$util$Map = cls3;
+            }
+            stringBuffer.append(cls3);
+            throw new IllegalArgumentException(stringBuffer.toString());
+        }
+    }
+
+    protected void populateMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map, Map map2) {
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            putCurrentEntryIntoMap(hierarchicalStreamReader, unmarshallingContext, map, map2);
+            hierarchicalStreamReader.moveUp();
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/PropertiesConverter.java

@@ -0,0 +1,100 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.unity3d.ads.metadata.MediationMetaData;
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class PropertiesConverter implements Converter {
+    static /* synthetic */ Class class$java$util$Properties;
+    private static final Field defaultsField;
+    private final boolean sort;
+
+    static {
+        Class cls = class$java$util$Properties;
+        if (cls == null) {
+            cls = class$("java.util.Properties");
+            class$java$util$Properties = cls;
+        }
+        Class cls2 = class$java$util$Properties;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Properties");
+            class$java$util$Properties = cls2;
+        }
+        defaultsField = Fields.locate(cls, cls2, false);
+    }
+
+    public PropertiesConverter() {
+        this(false);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$Properties;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Properties");
+            class$java$util$Properties = cls2;
+        }
+        return cls2 == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Properties properties;
+        Properties properties2 = (Properties) obj;
+        for (Map.Entry entry : (this.sort ? new TreeMap(properties2) : properties2).entrySet()) {
+            hierarchicalStreamWriter.startNode("property");
+            hierarchicalStreamWriter.addAttribute(MediationMetaData.KEY_NAME, entry.getKey().toString());
+            hierarchicalStreamWriter.addAttribute("value", entry.getValue().toString());
+            hierarchicalStreamWriter.endNode();
+        }
+        Field field = defaultsField;
+        if (field == null || (properties = (Properties) Fields.read(field, properties2)) == null) {
+            return;
+        }
+        hierarchicalStreamWriter.startNode("defaults");
+        marshal(properties, hierarchicalStreamWriter, marshallingContext);
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Properties properties = new Properties();
+        Properties properties2 = null;
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            if (hierarchicalStreamReader.getNodeName().equals("defaults")) {
+                properties2 = (Properties) unmarshal(hierarchicalStreamReader, unmarshallingContext);
+            } else {
+                properties.setProperty(hierarchicalStreamReader.getAttribute(MediationMetaData.KEY_NAME), hierarchicalStreamReader.getAttribute("value"));
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        if (properties2 == null) {
+            return properties;
+        }
+        Properties properties3 = new Properties(properties2);
+        properties3.putAll(properties);
+        return properties3;
+    }
+
+    public PropertiesConverter(boolean z) {
+        this.sort = z;
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/SingletonCollectionConverter.java

@@ -0,0 +1,27 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.util.Collections;
+
+/* loaded from: classes.dex */
+public class SingletonCollectionConverter extends CollectionConverter {
+    private static final Class LIST = Collections.singletonList(Boolean.TRUE).getClass();
+    private static final Class SET = Collections.singleton(Boolean.TRUE).getClass();
+
+    public SingletonCollectionConverter(Mapper mapper) {
+        super(mapper);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.CollectionConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return LIST == cls || SET == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.CollectionConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Object readCompleteItem = readCompleteItem(hierarchicalStreamReader, unmarshallingContext, null);
+        return unmarshallingContext.getRequiredType() == LIST ? Collections.singletonList(readCompleteItem) : Collections.singleton(readCompleteItem);
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/SingletonMapConverter.java

@@ -0,0 +1,29 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.util.Collections;
+
+/* loaded from: classes.dex */
+public class SingletonMapConverter extends MapConverter {
+    private static final Class MAP = Collections.singletonMap(Boolean.TRUE, null).getClass();
+
+    public SingletonMapConverter(Mapper mapper) {
+        super(mapper);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return MAP == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        hierarchicalStreamReader.moveDown();
+        Object readCompleteItem = readCompleteItem(hierarchicalStreamReader, unmarshallingContext, null);
+        Object readCompleteItem2 = readCompleteItem(hierarchicalStreamReader, unmarshallingContext, null);
+        hierarchicalStreamReader.moveUp();
+        return Collections.singletonMap(readCompleteItem, readCompleteItem2);
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/TreeMapConverter.java

@@ -0,0 +1,151 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.core.util.PresortedMap;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.util.Comparator;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class TreeMapConverter extends MapConverter {
+    private static final Comparator NULL_MARKER = new NullComparator();
+    static /* synthetic */ Class class$java$util$Comparator;
+    static /* synthetic */ Class class$java$util$TreeMap;
+    private static final Field comparatorField;
+
+    private static final class NullComparator extends Mapper.Null implements Comparator {
+        private NullComparator() {
+        }
+
+        @Override // java.util.Comparator
+        public int compare(Object obj, Object obj2) {
+            return ((Comparable) obj).compareTo(obj2);
+        }
+    }
+
+    static {
+        Class cls = class$java$util$TreeMap;
+        if (cls == null) {
+            cls = class$("java.util.TreeMap");
+            class$java$util$TreeMap = cls;
+        }
+        Class cls2 = class$java$util$Comparator;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Comparator");
+            class$java$util$Comparator = cls2;
+        }
+        comparatorField = Fields.locate(cls, cls2, false);
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public TreeMapConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
+        /*
+            r1 = this;
+            java.lang.Class r0 = com.thoughtworks.xstream.converters.collections.TreeMapConverter.class$java$util$TreeMap
+            if (r0 != 0) goto Lc
+            java.lang.String r0 = "java.util.TreeMap"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.converters.collections.TreeMapConverter.class$java$util$TreeMap = r0
+        Lc:
+            r1.<init>(r2, r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.collections.TreeMapConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        marshalComparator(((SortedMap) obj).comparator(), hierarchicalStreamWriter, marshallingContext);
+        super.marshal(obj, hierarchicalStreamWriter, marshallingContext);
+    }
+
+    protected void marshalComparator(Comparator comparator, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        if (comparator != null) {
+            hierarchicalStreamWriter.startNode("comparator");
+            hierarchicalStreamWriter.addAttribute(mapper().aliasForSystemAttribute("class"), mapper().serializedClass(comparator.getClass()));
+            marshallingContext.convertAnother(comparator);
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    protected void populateTreeMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, TreeMap treeMap, Comparator comparator) {
+        boolean z = comparator == NULL_MARKER;
+        Comparator comparator2 = null;
+        if (z) {
+            comparator = null;
+        }
+        if (comparator != null && JVM.hasOptimizedTreeMapPutAll()) {
+            comparator2 = comparator;
+        }
+        PresortedMap presortedMap = new PresortedMap(comparator2);
+        if (z) {
+            putCurrentEntryIntoMap(hierarchicalStreamReader, unmarshallingContext, treeMap, presortedMap);
+            hierarchicalStreamReader.moveUp();
+        }
+        populateMap(hierarchicalStreamReader, unmarshallingContext, treeMap, presortedMap);
+        try {
+            if (JVM.hasOptimizedTreeMapPutAll()) {
+                if (comparator != null && comparatorField != null) {
+                    comparatorField.set(treeMap, comparator);
+                }
+                treeMap.putAll(presortedMap);
+                return;
+            }
+            if (comparatorField == null) {
+                treeMap.putAll(presortedMap);
+                return;
+            }
+            comparatorField.set(treeMap, presortedMap.comparator());
+            treeMap.putAll(presortedMap);
+            comparatorField.set(treeMap, comparator);
+        } catch (IllegalAccessException e) {
+            throw new ObjectAccessException("Cannot set comparator of TreeMap", e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        TreeMap treeMap = comparatorField != null ? new TreeMap() : null;
+        Comparator unmarshalComparator = unmarshalComparator(hierarchicalStreamReader, unmarshallingContext, treeMap);
+        if (treeMap == null) {
+            treeMap = (unmarshalComparator == null || unmarshalComparator == NULL_MARKER) ? new TreeMap() : new TreeMap(unmarshalComparator);
+        }
+        populateTreeMap(hierarchicalStreamReader, unmarshallingContext, treeMap, unmarshalComparator);
+        return treeMap;
+    }
+
+    protected Comparator unmarshalComparator(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, TreeMap treeMap) {
+        Comparator comparator = null;
+        if (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            if (hierarchicalStreamReader.getNodeName().equals("comparator")) {
+                comparator = (Comparator) unmarshallingContext.convertAnother(treeMap, HierarchicalStreams.readClassType(hierarchicalStreamReader, mapper()));
+            } else if (!hierarchicalStreamReader.getNodeName().equals("no-comparator")) {
+                return NULL_MARKER;
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        return comparator;
+    }
+}

sources/com/thoughtworks/xstream/converters/collections/TreeSetConverter.java

@@ -0,0 +1,205 @@
+package com.thoughtworks.xstream.converters.collections;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.core.util.PresortedSet;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.util.AbstractList;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/* loaded from: classes.dex */
+public class TreeSetConverter extends CollectionConverter {
+    static /* synthetic */ Class class$java$lang$Object;
+    static /* synthetic */ Class class$java$util$SortedMap;
+    static /* synthetic */ Class class$java$util$TreeSet;
+    private static final Object constantValue;
+    private static final Field sortedMapField;
+    private transient TreeMapConverter treeMapConverter;
+
+    static {
+        Field field;
+        Map map;
+        Object obj = null;
+        if (JVM.hasOptimizedTreeSetAddAll()) {
+            Class cls = class$java$util$TreeSet;
+            if (cls == null) {
+                cls = class$("java.util.TreeSet");
+                class$java$util$TreeSet = cls;
+            }
+            Class cls2 = class$java$util$SortedMap;
+            if (cls2 == null) {
+                cls2 = class$("java.util.SortedMap");
+                class$java$util$SortedMap = cls2;
+            }
+            field = Fields.locate(cls, cls2, false);
+        } else {
+            field = null;
+        }
+        sortedMapField = field;
+        if (sortedMapField != null) {
+            TreeSet treeSet = new TreeSet();
+            treeSet.add("1");
+            treeSet.add("2");
+            try {
+                map = (Map) sortedMapField.get(treeSet);
+            } catch (IllegalAccessException unused) {
+                map = null;
+            }
+            if (map != null) {
+                Object[] array = map.values().toArray();
+                if (array[0] == array[1]) {
+                    obj = array[0];
+                }
+            }
+        } else {
+            Class cls3 = class$java$util$TreeSet;
+            if (cls3 == null) {
+                cls3 = class$("java.util.TreeSet");
+                class$java$util$TreeSet = cls3;
+            }
+            Class cls4 = class$java$lang$Object;
+            if (cls4 == null) {
+                cls4 = class$("java.lang.Object");
+                class$java$lang$Object = cls4;
+            }
+            Field locate = Fields.locate(cls3, cls4, true);
+            if (locate != null) {
+                try {
+                    obj = locate.get(null);
+                } catch (IllegalAccessException unused2) {
+                }
+            }
+        }
+        constantValue = obj;
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public TreeSetConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
+        /*
+            r1 = this;
+            java.lang.Class r0 = com.thoughtworks.xstream.converters.collections.TreeSetConverter.class$java$util$TreeSet
+            if (r0 != 0) goto Lc
+            java.lang.String r0 = "java.util.TreeSet"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.converters.collections.TreeSetConverter.class$java$util$TreeSet = r0
+        Lc:
+            r1.<init>(r2, r0)
+            r1.readResolve()
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.collections.TreeSetConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private Object readResolve() {
+        this.treeMapConverter = new TreeMapConverter(mapper()) { // from class: com.thoughtworks.xstream.converters.collections.TreeSetConverter.1
+            @Override // com.thoughtworks.xstream.converters.collections.MapConverter
+            protected void populateMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map, final Map map2) {
+                TreeSetConverter.this.populateCollection(hierarchicalStreamReader, unmarshallingContext, new AbstractList() { // from class: com.thoughtworks.xstream.converters.collections.TreeSetConverter.1.1
+                    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+                    public boolean add(Object obj) {
+                        return map2.put(obj, TreeSetConverter.constantValue != null ? TreeSetConverter.constantValue : obj) != null;
+                    }
+
+                    @Override // java.util.AbstractList, java.util.List
+                    public Object get(int i) {
+                        return null;
+                    }
+
+                    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+                    public int size() {
+                        return map2.size();
+                    }
+                });
+            }
+
+            @Override // com.thoughtworks.xstream.converters.collections.MapConverter
+            protected void putCurrentEntryIntoMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map, Map map2) {
+                Object readItem = readItem(hierarchicalStreamReader, unmarshallingContext, map);
+                map2.put(readItem, readItem);
+            }
+        };
+        return this;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.CollectionConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        this.treeMapConverter.marshalComparator(((SortedSet) obj).comparator(), hierarchicalStreamWriter, marshallingContext);
+        super.marshal(obj, hierarchicalStreamWriter, marshallingContext);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r4v10, types: [java.util.TreeSet] */
+    /* JADX WARN: Type inference failed for: r4v4, types: [java.util.Collection, java.util.TreeSet] */
+    /* JADX WARN: Type inference failed for: r4v5, types: [java.lang.Object, java.util.TreeSet] */
+    /* JADX WARN: Type inference failed for: r4v9, types: [java.util.TreeSet] */
+    /* JADX WARN: Type inference failed for: r5v0, types: [java.lang.reflect.Field] */
+    /* JADX WARN: Type inference failed for: r7v0, types: [com.thoughtworks.xstream.converters.collections.CollectionConverter, com.thoughtworks.xstream.converters.collections.TreeSetConverter] */
+    @Override // com.thoughtworks.xstream.converters.collections.CollectionConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        TreeMap treeMap;
+        TreeMap treeMap2;
+        TreeMap treeMap3;
+        TreeMap treeMap4 = null;
+        Comparator unmarshalComparator = this.treeMapConverter.unmarshalComparator(hierarchicalStreamReader, unmarshallingContext, null);
+        boolean z = unmarshalComparator instanceof Mapper.Null;
+        Comparator comparator = z ? null : unmarshalComparator;
+        if (sortedMapField != null) {
+            ?? treeSet = comparator == null ? new TreeSet() : new TreeSet(comparator);
+            try {
+                Object obj = sortedMapField.get(treeSet);
+                if (obj instanceof TreeMap) {
+                    treeMap3 = (TreeMap) obj;
+                    treeMap4 = treeSet;
+                } else {
+                    treeMap3 = null;
+                }
+                treeMap = treeMap4;
+                treeMap4 = treeMap3;
+            } catch (IllegalAccessException e) {
+                throw new ObjectAccessException("Cannot get backing map of TreeSet", e);
+            }
+        } else {
+            treeMap = null;
+        }
+        if (treeMap4 == null) {
+            PresortedSet presortedSet = new PresortedSet(comparator);
+            ?? treeSet2 = comparator == null ? new TreeSet() : new TreeSet(comparator);
+            if (z) {
+                addCurrentElementToCollection(hierarchicalStreamReader, unmarshallingContext, treeSet2, presortedSet);
+                hierarchicalStreamReader.moveUp();
+            }
+            populateCollection(hierarchicalStreamReader, unmarshallingContext, treeSet2, presortedSet);
+            treeMap2 = treeSet2;
+            if (presortedSet.size() > 0) {
+                treeSet2.addAll(presortedSet);
+                treeMap2 = treeSet2;
+            }
+        } else {
+            this.treeMapConverter.populateTreeMap(hierarchicalStreamReader, unmarshallingContext, treeMap4, unmarshalComparator);
+            treeMap2 = treeMap;
+        }
+        return treeMap2;
+    }
+}

sources/com/thoughtworks/xstream/converters/enums/EnumConverter.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.converters.enums;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public class EnumConverter implements Converter {
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return (cls != null && cls.isEnum()) || Enum.class.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.setValue(((Enum) obj).name());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Class requiredType = unmarshallingContext.getRequiredType();
+        if (requiredType.getSuperclass() != Enum.class) {
+            requiredType = requiredType.getSuperclass();
+        }
+        String value = hierarchicalStreamReader.getValue();
+        try {
+            return Enum.valueOf(requiredType, value);
+        } catch (IllegalArgumentException e) {
+            for (Enum r3 : (Enum[]) requiredType.getEnumConstants()) {
+                if (r3.name().equalsIgnoreCase(value)) {
+                    return r3;
+                }
+            }
+            throw e;
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/enums/EnumMapConverter.java

@@ -0,0 +1,47 @@
+package com.thoughtworks.xstream.converters.enums;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.collections.MapConverter;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.util.EnumMap;
+
+/* loaded from: classes.dex */
+public class EnumMapConverter extends MapConverter {
+    private static final Field typeField = Fields.locate(EnumMap.class, Class.class, false);
+
+    public EnumMapConverter(Mapper mapper) {
+        super(mapper);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return typeField != null && cls == EnumMap.class;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Class cls = (Class) Fields.read(typeField, obj);
+        String aliasForSystemAttribute = mapper().aliasForSystemAttribute("enum-type");
+        if (aliasForSystemAttribute != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, mapper().serializedClass(cls));
+        }
+        super.marshal(obj, hierarchicalStreamWriter, marshallingContext);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String aliasForSystemAttribute = mapper().aliasForSystemAttribute("enum-type");
+        if (aliasForSystemAttribute == null) {
+            throw new ConversionException("No EnumType specified for EnumMap");
+        }
+        EnumMap enumMap = new EnumMap(mapper().realClass(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute)));
+        populateMap(hierarchicalStreamReader, unmarshallingContext, enumMap);
+        return enumMap;
+    }
+}

sources/com/thoughtworks/xstream/converters/enums/EnumSetConverter.java

@@ -0,0 +1,71 @@
+package com.thoughtworks.xstream.converters.enums;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.util.EnumSet;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class EnumSetConverter implements Converter {
+    private static final Field typeField = Fields.locate(EnumSet.class, Class.class, false);
+    private final Mapper mapper;
+
+    public EnumSetConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    private String joinEnumValues(EnumSet enumSet) {
+        StringBuffer stringBuffer = new StringBuffer();
+        Iterator it = enumSet.iterator();
+        boolean z = false;
+        while (it.hasNext()) {
+            Enum r2 = (Enum) it.next();
+            if (z) {
+                stringBuffer.append(',');
+            } else {
+                z = true;
+            }
+            stringBuffer.append(r2.name());
+        }
+        return stringBuffer.toString();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return (typeField == null || cls == null || !EnumSet.class.isAssignableFrom(cls)) ? false : true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        EnumSet enumSet = (EnumSet) obj;
+        Class cls = (Class) Fields.read(typeField, enumSet);
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("enum-type");
+        if (aliasForSystemAttribute != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(cls));
+        }
+        hierarchicalStreamWriter.setValue(joinEnumValues(enumSet));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("enum-type");
+        if (aliasForSystemAttribute == null) {
+            throw new ConversionException("No EnumType specified for EnumSet");
+        }
+        Class realClass = this.mapper.realClass(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute));
+        EnumSet noneOf = EnumSet.noneOf(realClass);
+        for (String str : hierarchicalStreamReader.getValue().split(",")) {
+            if (str.length() > 0) {
+                noneOf.add(Enum.valueOf(realClass, str));
+            }
+        }
+        return noneOf;
+    }
+}

sources/com/thoughtworks/xstream/converters/enums/EnumSingleValueConverter.java

@@ -0,0 +1,30 @@
+package com.thoughtworks.xstream.converters.enums;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+
+/* loaded from: classes.dex */
+public class EnumSingleValueConverter extends AbstractSingleValueConverter {
+    private final Class<? extends Enum> enumType;
+
+    public EnumSingleValueConverter(Class<? extends Enum> cls) {
+        if (!Enum.class.isAssignableFrom(cls) && cls != Enum.class) {
+            throw new IllegalArgumentException("Converter can only handle defined enums");
+        }
+        this.enumType = cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && this.enumType.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Enum.valueOf(this.enumType, str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return ((Enum) Enum.class.cast(obj)).name();
+    }
+}

sources/com/thoughtworks/xstream/converters/enums/EnumToStringConverter.java

@@ -0,0 +1,87 @@
+package com.thoughtworks.xstream.converters.enums;
+
+import com.thoughtworks.xstream.InitializationException;
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.lang.Enum;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class EnumToStringConverter<T extends Enum<T>> extends AbstractSingleValueConverter {
+    private final Class<T> enumType;
+    private final Map<String, T> strings;
+    private final EnumMap<T, String> values;
+
+    public EnumToStringConverter(Class<T> cls) {
+        this(cls, extractStringMap(cls), null);
+    }
+
+    private static <T extends Enum<T>> EnumMap<T, String> buildValueMap(Class<T> cls, Map<String, T> map) {
+        EnumMap<T, String> enumMap = new EnumMap<>(cls);
+        for (Map.Entry<String, T> entry : map.entrySet()) {
+            enumMap.put((EnumMap<T, String>) entry.getValue(), (T) entry.getKey());
+        }
+        return enumMap;
+    }
+
+    private static <T> void checkType(Class<T> cls) {
+        if (!Enum.class.isAssignableFrom(cls) && cls != Enum.class) {
+            throw new InitializationException("Converter can only handle enum types");
+        }
+    }
+
+    private static <T extends Enum<T>> Map<String, T> extractStringMap(Class<T> cls) {
+        checkType(cls);
+        EnumSet allOf = EnumSet.allOf(cls);
+        HashMap hashMap = new HashMap(allOf.size());
+        Iterator it = allOf.iterator();
+        while (it.hasNext()) {
+            Enum r2 = (Enum) it.next();
+            if (hashMap.put(r2.toString(), r2) != null) {
+                throw new InitializationException("Enum type " + cls.getName() + " does not have unique string representations for its values");
+            }
+        }
+        return hashMap;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && this.enumType.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        if (str == null) {
+            return null;
+        }
+        T t = this.strings.get(str);
+        if (t != null) {
+            return t;
+        }
+        ConversionException conversionException = new ConversionException("Invalid string representation for enum type");
+        conversionException.add("enum-type", this.enumType.getName());
+        conversionException.add("enum-string", str);
+        throw conversionException;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Enum r2 = (Enum) Enum.class.cast(obj);
+        EnumMap<T, String> enumMap = this.values;
+        return enumMap == null ? r2.toString() : enumMap.get(r2);
+    }
+
+    public EnumToStringConverter(Class<T> cls, Map<String, T> map) {
+        this(cls, map, buildValueMap(cls, map));
+    }
+
+    private EnumToStringConverter(Class<T> cls, Map<String, T> map, EnumMap<T, String> enumMap) {
+        this.enumType = cls;
+        this.strings = map;
+        this.values = enumMap;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ActivationDataFlavorConverter.java

@@ -0,0 +1,92 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import javax.activation.ActivationDataFlavor;
+
+/* loaded from: classes.dex */
+public class ActivationDataFlavorConverter implements Converter {
+    static /* synthetic */ Class class$java$lang$Class;
+    static /* synthetic */ Class class$javax$activation$ActivationDataFlavor;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$javax$activation$ActivationDataFlavor;
+        if (cls2 == null) {
+            cls2 = class$("javax.activation.ActivationDataFlavor");
+            class$javax$activation$ActivationDataFlavor = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        ActivationDataFlavor activationDataFlavor = (ActivationDataFlavor) obj;
+        String mimeType = activationDataFlavor.getMimeType();
+        if (mimeType != null) {
+            hierarchicalStreamWriter.startNode("mimeType");
+            hierarchicalStreamWriter.setValue(mimeType);
+            hierarchicalStreamWriter.endNode();
+        }
+        String humanPresentableName = activationDataFlavor.getHumanPresentableName();
+        if (humanPresentableName != null) {
+            hierarchicalStreamWriter.startNode("humanRepresentableName");
+            hierarchicalStreamWriter.setValue(humanPresentableName);
+            hierarchicalStreamWriter.endNode();
+        }
+        Class representationClass = activationDataFlavor.getRepresentationClass();
+        if (representationClass != null) {
+            hierarchicalStreamWriter.startNode("representationClass");
+            marshallingContext.convertAnother(representationClass);
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Class cls = null;
+        String str = null;
+        String str2 = null;
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            if (nodeName.equals("mimeType")) {
+                str = hierarchicalStreamReader.getValue();
+            } else if (nodeName.equals("humanRepresentableName")) {
+                str2 = hierarchicalStreamReader.getValue();
+            } else {
+                if (!nodeName.equals("representationClass")) {
+                    ConversionException conversionException = new ConversionException("Unknown child element");
+                    conversionException.add("element", hierarchicalStreamReader.getNodeName());
+                    throw conversionException;
+                }
+                Class cls2 = class$java$lang$Class;
+                if (cls2 == null) {
+                    cls2 = class$("java.lang.Class");
+                    class$java$lang$Class = cls2;
+                }
+                cls = (Class) unmarshallingContext.convertAnother(null, cls2);
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        try {
+            return cls == null ? new ActivationDataFlavor(str, str2) : str == null ? new ActivationDataFlavor(cls, str2) : new ActivationDataFlavor(cls, str, str2);
+        } catch (IllegalArgumentException e) {
+            throw new ConversionException(e);
+        } catch (NullPointerException e2) {
+            throw new ConversionException(e2);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/CharsetConverter.java

@@ -0,0 +1,45 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.nio.charset.Charset;
+
+/* loaded from: classes.dex */
+public class CharsetConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$nio$charset$Charset;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$java$nio$charset$Charset;
+            if (cls2 == null) {
+                cls2 = class$("java.nio.charset.Charset");
+                class$java$nio$charset$Charset = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Charset.forName(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        return ((Charset) obj).name();
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ColorConverter.java

@@ -0,0 +1,44 @@
+package com.thoughtworks.xstream.converters.extended;
+
+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 java.awt.Color;
+import java.util.HashMap;
+
+/* loaded from: classes.dex */
+public class ColorConverter implements Converter {
+    private void write(String str, int i, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, str, Integer.TYPE);
+        hierarchicalStreamWriter.setValue(String.valueOf(i));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && cls.getName().equals("java.awt.Color");
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Color color = (Color) obj;
+        write("red", color.getRed(), hierarchicalStreamWriter);
+        write("green", color.getGreen(), hierarchicalStreamWriter);
+        write("blue", color.getBlue(), hierarchicalStreamWriter);
+        write("alpha", color.getAlpha(), hierarchicalStreamWriter);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        HashMap hashMap = new HashMap();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            hashMap.put(hierarchicalStreamReader.getNodeName(), Integer.valueOf(hierarchicalStreamReader.getValue()));
+            hierarchicalStreamReader.moveUp();
+        }
+        return new Color(((Integer) hashMap.get("red")).intValue(), ((Integer) hashMap.get("green")).intValue(), ((Integer) hashMap.get("blue")).intValue(), ((Integer) hashMap.get("alpha")).intValue());
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/CurrencyConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.util.Currency;
+
+/* loaded from: classes.dex */
+public class CurrencyConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$util$Currency;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$Currency;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Currency");
+            class$java$util$Currency = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Currency.getInstance(str);
+    }
+}

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

@@ -0,0 +1,56 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+
+/* loaded from: classes.dex */
+public class DurationConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$javax$xml$datatype$Duration;
+    private final DatatypeFactory factory;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [com.thoughtworks.xstream.converters.extended.DurationConverter$1] */
+    public DurationConverter() {
+        this(new Object() { // from class: com.thoughtworks.xstream.converters.extended.DurationConverter.1
+            DatatypeFactory getFactory() {
+                try {
+                    return DatatypeFactory.newInstance();
+                } catch (DatatypeConfigurationException unused) {
+                    return null;
+                }
+            }
+        }.getFactory());
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (this.factory != null && cls != null) {
+            Class cls2 = class$javax$xml$datatype$Duration;
+            if (cls2 == null) {
+                cls2 = class$("javax.xml.datatype.Duration");
+                class$javax$xml$datatype$Duration = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.factory.newDuration(str);
+    }
+
+    public DurationConverter(DatatypeFactory datatypeFactory) {
+        this.factory = datatypeFactory;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/DynamicProxyConverter.java

@@ -0,0 +1,160 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.ClassLoaderReference;
+import com.thoughtworks.xstream.core.util.Fields;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public class DynamicProxyConverter implements Converter {
+    private static final InvocationHandler DUMMY;
+    private static final Field HANDLER;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
+    static /* synthetic */ Class class$java$lang$reflect$InvocationHandler;
+    static /* synthetic */ Class class$java$lang$reflect$Proxy;
+    private ClassLoaderReference classLoaderReference;
+    private Mapper mapper;
+
+    static {
+        Class cls = class$java$lang$reflect$Proxy;
+        if (cls == null) {
+            cls = class$("java.lang.reflect.Proxy");
+            class$java$lang$reflect$Proxy = cls;
+        }
+        Class cls2 = class$java$lang$reflect$InvocationHandler;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.reflect.InvocationHandler");
+            class$java$lang$reflect$InvocationHandler = cls2;
+        }
+        HANDLER = Fields.locate(cls, cls2, false);
+        DUMMY = new InvocationHandler() { // from class: com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.1
+            @Override // java.lang.reflect.InvocationHandler
+            public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+                return null;
+            }
+        };
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public DynamicProxyConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
+        /*
+            r1 = this;
+            java.lang.Class r0 = com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter
+            if (r0 != 0) goto Lc
+            java.lang.String r0 = "com.thoughtworks.xstream.converters.extended.DynamicProxyConverter"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter = r0
+        Lc:
+            java.lang.ClassLoader r0 = r0.getClassLoader()
+            r1.<init>(r2, r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
+    }
+
+    private void addInterfacesToXml(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        for (Class<?> cls : obj.getClass().getInterfaces()) {
+            hierarchicalStreamWriter.startNode("interface");
+            hierarchicalStreamWriter.setValue(this.mapper.serializedClass(cls));
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.DynamicProxyMapper$DynamicProxy");
+                class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy = cls2;
+            }
+            if (cls.equals(cls2) || Proxy.isProxyClass(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        InvocationHandler invocationHandler = Proxy.getInvocationHandler(obj);
+        addInterfacesToXml(obj, hierarchicalStreamWriter);
+        hierarchicalStreamWriter.startNode("handler");
+        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class");
+        if (aliasForSystemAttribute != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(invocationHandler.getClass()));
+        }
+        marshallingContext.convertAnother(invocationHandler);
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Class cls;
+        String aliasForSystemAttribute;
+        ArrayList arrayList = new ArrayList();
+        while (true) {
+            if (!hierarchicalStreamReader.hasMoreChildren()) {
+                cls = null;
+                break;
+            }
+            hierarchicalStreamReader.moveDown();
+            String nodeName = hierarchicalStreamReader.getNodeName();
+            if (!nodeName.equals("interface")) {
+                if (nodeName.equals("handler") && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class")) != null) {
+                    cls = this.mapper.realClass(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute));
+                    break;
+                }
+            } else {
+                arrayList.add(this.mapper.realClass(hierarchicalStreamReader.getValue()));
+            }
+            hierarchicalStreamReader.moveUp();
+        }
+        if (cls == null) {
+            throw new ConversionException("No InvocationHandler specified for dynamic proxy");
+        }
+        Class[] clsArr = new Class[arrayList.size()];
+        arrayList.toArray(clsArr);
+        Object newProxyInstance = HANDLER != null ? Proxy.newProxyInstance(this.classLoaderReference.getReference(), clsArr, DUMMY) : null;
+        InvocationHandler invocationHandler = (InvocationHandler) unmarshallingContext.convertAnother(newProxyInstance, cls);
+        hierarchicalStreamReader.moveUp();
+        Field field = HANDLER;
+        if (field == null) {
+            return Proxy.newProxyInstance(this.classLoaderReference.getReference(), clsArr, invocationHandler);
+        }
+        Fields.write(field, newProxyInstance, invocationHandler);
+        return newProxyInstance;
+    }
+
+    public DynamicProxyConverter(Mapper mapper, ClassLoaderReference classLoaderReference) {
+        this.classLoaderReference = classLoaderReference;
+        this.mapper = mapper;
+    }
+
+    public DynamicProxyConverter(Mapper mapper, ClassLoader classLoader) {
+        this(mapper, new ClassLoaderReference(classLoader));
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/EncodedByteArrayConverter.java

@@ -0,0 +1,74 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.basic.ByteConverter;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.StringCodec;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class EncodedByteArrayConverter implements Converter, SingleValueConverter {
+    private static final ByteConverter byteConverter = new ByteConverter();
+    private final StringCodec codec;
+
+    public EncodedByteArrayConverter() {
+        this(JVM.getBase64Codec());
+    }
+
+    private Object unmarshalIndividualByteElements(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        ArrayList arrayList = new ArrayList();
+        int i = 0;
+        boolean z = true;
+        while (true) {
+            if (!z && !hierarchicalStreamReader.hasMoreChildren()) {
+                break;
+            }
+            hierarchicalStreamReader.moveDown();
+            arrayList.add(byteConverter.fromString(hierarchicalStreamReader.getValue()));
+            hierarchicalStreamReader.moveUp();
+            z = false;
+        }
+        byte[] bArr = new byte[arrayList.size()];
+        Iterator it = arrayList.iterator();
+        while (it.hasNext()) {
+            bArr[i] = ((Byte) it.next()).byteValue();
+            i++;
+        }
+        return bArr;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && cls.isArray() && cls.getComponentType().equals(Byte.TYPE);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.codec.decode(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.setValue(toString(obj));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return this.codec.encode((byte[]) obj);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return !hierarchicalStreamReader.hasMoreChildren() ? fromString(hierarchicalStreamReader.getValue()) : unmarshalIndividualByteElements(hierarchicalStreamReader, unmarshallingContext);
+    }
+
+    public EncodedByteArrayConverter(StringCodec stringCodec) {
+        this.codec = stringCodec;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/FileConverter.java

@@ -0,0 +1,37 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.io.File;
+
+/* loaded from: classes.dex */
+public class FileConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$io$File;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$io$File;
+        if (cls2 == null) {
+            cls2 = class$("java.io.File");
+            class$java$io$File = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return new File(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return ((File) obj).getPath();
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/FontConverter.java

@@ -0,0 +1,138 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.JVM;
+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.awt.Font;
+import java.awt.font.TextAttribute;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import javax.swing.plaf.FontUIResource;
+
+/* loaded from: classes.dex */
+public class FontConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    static /* synthetic */ Class class$java$util$Map;
+    static /* synthetic */ Class class$javax$swing$plaf$FontUIResource;
+    private final Mapper mapper;
+    private final SingleValueConverter textAttributeConverter;
+
+    public FontConverter() {
+        this(null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && (cls.getName().equals("java.awt.Font") || cls.getName().equals("javax.swing.plaf.FontUIResource"));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Class<?> cls;
+        Map attributes = ((Font) obj).getAttributes();
+        Mapper mapper = this.mapper;
+        if (mapper == null) {
+            hierarchicalStreamWriter.startNode("attributes");
+            marshallingContext.convertAnother(attributes);
+            hierarchicalStreamWriter.endNode();
+            return;
+        }
+        String aliasForSystemAttribute = mapper.aliasForSystemAttribute("class");
+        for (Map.Entry entry : attributes.entrySet()) {
+            String singleValueConverter = this.textAttributeConverter.toString(entry.getKey());
+            Object value = entry.getValue();
+            if (value != null) {
+                cls = value.getClass();
+            } else {
+                cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+                if (cls == null) {
+                    cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                    class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+                }
+            }
+            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, singleValueConverter, cls);
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(cls));
+            if (value != null) {
+                marshallingContext.convertAnother(value);
+            }
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Map map;
+        if (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            if (hierarchicalStreamReader.getNodeName().equals("attributes")) {
+                Class cls = class$java$util$Map;
+                if (cls == null) {
+                    cls = class$("java.util.Map");
+                    class$java$util$Map = cls;
+                }
+                map = (Map) unmarshallingContext.convertAnother(null, cls);
+                hierarchicalStreamReader.moveUp();
+            } else {
+                String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class");
+                map = new HashMap();
+                do {
+                    if (!map.isEmpty()) {
+                        hierarchicalStreamReader.moveDown();
+                    }
+                    Class realClass = this.mapper.realClass(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute));
+                    TextAttribute textAttribute = (TextAttribute) this.textAttributeConverter.fromString(hierarchicalStreamReader.getNodeName());
+                    Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+                    if (cls2 == null) {
+                        cls2 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                        class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+                    }
+                    map.put(textAttribute, realClass == cls2 ? null : unmarshallingContext.convertAnother(null, realClass));
+                    hierarchicalStreamReader.moveUp();
+                } while (hierarchicalStreamReader.hasMoreChildren());
+            }
+        } else {
+            map = Collections.EMPTY_MAP;
+        }
+        if (!JVM.isVersion(6)) {
+            Iterator it = map.values().iterator();
+            while (it.hasNext()) {
+                if (it.next() == null) {
+                    it.remove();
+                }
+            }
+        }
+        Font font = Font.getFont(map);
+        Class requiredType = unmarshallingContext.getRequiredType();
+        Class cls3 = class$javax$swing$plaf$FontUIResource;
+        if (cls3 == null) {
+            cls3 = class$("javax.swing.plaf.FontUIResource");
+            class$javax$swing$plaf$FontUIResource = cls3;
+        }
+        return requiredType == cls3 ? new FontUIResource(font) : font;
+    }
+
+    public FontConverter(Mapper mapper) {
+        this.mapper = mapper;
+        if (mapper == null) {
+            this.textAttributeConverter = null;
+        } else {
+            this.textAttributeConverter = new TextAttributeConverter();
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/GregorianCalendarConverter.java

@@ -0,0 +1,70 @@
+package com.thoughtworks.xstream.converters.extended;
+
+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 java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+/* loaded from: classes.dex */
+public class GregorianCalendarConverter implements Converter {
+    static /* synthetic */ Class class$java$lang$String;
+    static /* synthetic */ Class class$java$util$GregorianCalendar;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$GregorianCalendar;
+        if (cls2 == null) {
+            cls2 = class$("java.util.GregorianCalendar");
+            class$java$util$GregorianCalendar = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        GregorianCalendar gregorianCalendar = (GregorianCalendar) obj;
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "time", Long.TYPE);
+        hierarchicalStreamWriter.setValue(String.valueOf(gregorianCalendar.getTime().getTime()));
+        hierarchicalStreamWriter.endNode();
+        Class cls = class$java$lang$String;
+        if (cls == null) {
+            cls = class$("java.lang.String");
+            class$java$lang$String = cls;
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "timezone", cls);
+        hierarchicalStreamWriter.setValue(gregorianCalendar.getTimeZone().getID());
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String id;
+        hierarchicalStreamReader.moveDown();
+        long parseLong = Long.parseLong(hierarchicalStreamReader.getValue());
+        hierarchicalStreamReader.moveUp();
+        if (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            id = hierarchicalStreamReader.getValue();
+            hierarchicalStreamReader.moveUp();
+        } else {
+            id = TimeZone.getDefault().getID();
+        }
+        GregorianCalendar gregorianCalendar = new GregorianCalendar();
+        gregorianCalendar.setTimeZone(TimeZone.getTimeZone(id));
+        gregorianCalendar.setTime(new Date(parseLong));
+        return gregorianCalendar;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ISO8601DateConverter.java

@@ -0,0 +1,53 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.util.Calendar;
+import java.util.Date;
+
+/* loaded from: classes.dex */
+public class ISO8601DateConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$util$Date;
+    static /* synthetic */ Class class$java$util$GregorianCalendar;
+    private final ISO8601GregorianCalendarConverter converter = new ISO8601GregorianCalendarConverter();
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$Date;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Date");
+            class$java$util$Date = cls2;
+        }
+        if (cls == cls2) {
+            ISO8601GregorianCalendarConverter iSO8601GregorianCalendarConverter = this.converter;
+            Class cls3 = class$java$util$GregorianCalendar;
+            if (cls3 == null) {
+                cls3 = class$("java.util.GregorianCalendar");
+                class$java$util$GregorianCalendar = cls3;
+            }
+            if (iSO8601GregorianCalendarConverter.canConvert(cls3)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return ((Calendar) this.converter.fromString(str)).getTime();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime((Date) obj);
+        return this.converter.toString(calendar);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ISO8601GregorianCalendarConverter.java

@@ -0,0 +1,57 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import com.thoughtworks.xstream.core.JVM;
+import java.lang.reflect.InvocationTargetException;
+
+/* loaded from: classes.dex */
+public class ISO8601GregorianCalendarConverter extends AbstractSingleValueConverter {
+    private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
+    private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+    static /* synthetic */ Class class$java$util$GregorianCalendar;
+    private final SingleValueConverter converter;
+
+    public ISO8601GregorianCalendarConverter() {
+        SingleValueConverter singleValueConverter;
+        try {
+            singleValueConverter = (SingleValueConverter) JVM.loadClassForName(JVM.isVersion(8) ? "com.thoughtworks.xstream.core.util.ISO8601JavaTimeConverter" : "com.thoughtworks.xstream.core.util.ISO8601JodaTimeConverter").getDeclaredConstructor(EMPTY_CLASS_ARRAY).newInstance(EMPTY_OBJECT_ARRAY);
+        } catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException unused) {
+            singleValueConverter = null;
+        }
+        this.converter = singleValueConverter;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (this.converter != null) {
+            Class cls2 = class$java$util$GregorianCalendar;
+            if (cls2 == null) {
+                cls2 = class$("java.util.GregorianCalendar");
+                class$java$util$GregorianCalendar = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.converter.fromString(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return this.converter.toString(obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ISO8601SqlTimestampConverter.java

@@ -0,0 +1,75 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import java.sql.Timestamp;
+import java.util.Date;
+
+/* loaded from: classes.dex */
+public class ISO8601SqlTimestampConverter extends ISO8601DateConverter {
+    private static final String PADDING = "000000000";
+    static /* synthetic */ Class class$java$sql$Timestamp;
+    static /* synthetic */ Class class$java$util$Date;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.extended.ISO8601DateConverter, com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$sql$Timestamp;
+        if (cls2 == null) {
+            cls2 = class$("java.sql.Timestamp");
+            class$java$sql$Timestamp = cls2;
+        }
+        if (cls == cls2) {
+            Class cls3 = class$java$util$Date;
+            if (cls3 == null) {
+                cls3 = class$("java.util.Date");
+                class$java$util$Date = cls3;
+            }
+            if (super.canConvert(cls3)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.extended.ISO8601DateConverter, com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        int lastIndexOf = str.lastIndexOf(46);
+        int i = 0;
+        if (lastIndexOf > 0) {
+            int i2 = lastIndexOf + 1;
+            int i3 = i2;
+            while (Character.isDigit(str.charAt(i3))) {
+                i3++;
+            }
+            int parseInt = Integer.parseInt(str.substring(i2, i3));
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(str.substring(0, lastIndexOf));
+            stringBuffer.append(str.substring(i3));
+            str = stringBuffer.toString();
+            i = parseInt;
+        }
+        Timestamp timestamp = new Timestamp(((Date) super.fromString(str)).getTime());
+        timestamp.setNanos(i);
+        return timestamp;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.extended.ISO8601DateConverter, com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Timestamp timestamp = (Timestamp) obj;
+        String iSO8601DateConverter = super.toString(new Date((timestamp.getTime() / 1000) * 1000));
+        String valueOf = String.valueOf(timestamp.getNanos());
+        int lastIndexOf = iSO8601DateConverter.lastIndexOf(46);
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(iSO8601DateConverter.substring(0, lastIndexOf + 1));
+        stringBuffer.append(PADDING.substring(valueOf.length()));
+        stringBuffer.append(valueOf);
+        stringBuffer.append(iSO8601DateConverter.substring(lastIndexOf + 4));
+        return stringBuffer.toString();
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/JavaClassConverter.java

@@ -0,0 +1,61 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import com.thoughtworks.xstream.core.ClassLoaderReference;
+import com.thoughtworks.xstream.mapper.CannotResolveClassException;
+import com.thoughtworks.xstream.mapper.DefaultMapper;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+public class JavaClassConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$lang$Class;
+    private Mapper mapper;
+
+    public JavaClassConverter(ClassLoaderReference classLoaderReference) {
+        this(new DefaultMapper(classLoaderReference));
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$Class;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.Class");
+            class$java$lang$Class = cls2;
+        }
+        return cls2.equals(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        try {
+            return this.mapper.realClass(str);
+        } catch (CannotResolveClassException e) {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append("Cannot load java class ");
+            stringBuffer.append(str);
+            throw new ConversionException(stringBuffer.toString(), e.getCause());
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return this.mapper.serializedClass((Class) obj);
+    }
+
+    public JavaClassConverter(ClassLoader classLoader) {
+        this(new ClassLoaderReference(classLoader));
+    }
+
+    protected JavaClassConverter(Mapper mapper) {
+        this.mapper = mapper;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/JavaFieldConverter.java

@@ -0,0 +1,87 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.ClassLoaderReference;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.DefaultMapper;
+import com.thoughtworks.xstream.mapper.Mapper;
+import com.unity3d.ads.metadata.MediationMetaData;
+import java.lang.reflect.Field;
+
+/* loaded from: classes.dex */
+public class JavaFieldConverter implements Converter {
+    static /* synthetic */ Class class$java$lang$reflect$Field;
+    private final SingleValueConverter javaClassConverter;
+    private final Mapper mapper;
+
+    public JavaFieldConverter(ClassLoaderReference classLoaderReference) {
+        this(new JavaClassConverter(classLoaderReference), new DefaultMapper(classLoaderReference));
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$reflect$Field;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.reflect.Field");
+            class$java$lang$reflect$Field = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Field field = (Field) obj;
+        Class<?> declaringClass = field.getDeclaringClass();
+        hierarchicalStreamWriter.startNode(MediationMetaData.KEY_NAME);
+        hierarchicalStreamWriter.setValue(this.mapper.serializedMember(declaringClass, field.getName()));
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("clazz");
+        hierarchicalStreamWriter.setValue(this.javaClassConverter.toString(declaringClass));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        String str = null;
+        String str2 = null;
+        while (true) {
+            if ((str == null || str2 == null) && hierarchicalStreamReader.hasMoreChildren()) {
+                hierarchicalStreamReader.moveDown();
+                if (hierarchicalStreamReader.getNodeName().equals(MediationMetaData.KEY_NAME)) {
+                    str = hierarchicalStreamReader.getValue();
+                } else if (hierarchicalStreamReader.getNodeName().equals("clazz")) {
+                    str2 = hierarchicalStreamReader.getValue();
+                }
+                hierarchicalStreamReader.moveUp();
+            }
+        }
+        Class cls = (Class) this.javaClassConverter.fromString(str2);
+        try {
+            return cls.getDeclaredField(this.mapper.realMember(cls, str));
+        } catch (NoSuchFieldException e) {
+            throw new ConversionException(e);
+        }
+    }
+
+    public JavaFieldConverter(ClassLoader classLoader) {
+        this(new ClassLoaderReference(classLoader));
+    }
+
+    protected JavaFieldConverter(SingleValueConverter singleValueConverter, Mapper mapper) {
+        this.javaClassConverter = singleValueConverter;
+        this.mapper = mapper;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/JavaMethodConverter.java

@@ -0,0 +1,126 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.ClassLoaderReference;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.unity3d.ads.metadata.MediationMetaData;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public class JavaMethodConverter implements Converter {
+    static /* synthetic */ Class class$java$lang$reflect$Constructor;
+    static /* synthetic */ Class class$java$lang$reflect$Method;
+    private final SingleValueConverter javaClassConverter;
+
+    public JavaMethodConverter(ClassLoaderReference classLoaderReference) {
+        this(new JavaClassConverter(classLoaderReference));
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private void marshalMethod(HierarchicalStreamWriter hierarchicalStreamWriter, String str, String str2, Class[] clsArr) {
+        hierarchicalStreamWriter.startNode("class");
+        hierarchicalStreamWriter.setValue(str);
+        hierarchicalStreamWriter.endNode();
+        if (str2 != null) {
+            hierarchicalStreamWriter.startNode(MediationMetaData.KEY_NAME);
+            hierarchicalStreamWriter.setValue(str2);
+            hierarchicalStreamWriter.endNode();
+        }
+        hierarchicalStreamWriter.startNode("parameter-types");
+        for (Class cls : clsArr) {
+            hierarchicalStreamWriter.startNode("class");
+            hierarchicalStreamWriter.setValue(this.javaClassConverter.toString(cls));
+            hierarchicalStreamWriter.endNode();
+        }
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$reflect$Method;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.reflect.Method");
+            class$java$lang$reflect$Method = cls2;
+        }
+        if (cls != cls2) {
+            Class cls3 = class$java$lang$reflect$Constructor;
+            if (cls3 == null) {
+                cls3 = class$("java.lang.reflect.Constructor");
+                class$java$lang$reflect$Constructor = cls3;
+            }
+            if (cls != cls3) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        if (obj instanceof Method) {
+            Method method = (Method) obj;
+            marshalMethod(hierarchicalStreamWriter, this.javaClassConverter.toString(method.getDeclaringClass()), method.getName(), method.getParameterTypes());
+        } else {
+            Constructor constructor = (Constructor) obj;
+            marshalMethod(hierarchicalStreamWriter, this.javaClassConverter.toString(constructor.getDeclaringClass()), null, constructor.getParameterTypes());
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Class cls;
+        try {
+            Class requiredType = unmarshallingContext.getRequiredType();
+            if (class$java$lang$reflect$Method == null) {
+                cls = class$("java.lang.reflect.Method");
+                class$java$lang$reflect$Method = cls;
+            } else {
+                cls = class$java$lang$reflect$Method;
+            }
+            boolean equals = requiredType.equals(cls);
+            hierarchicalStreamReader.moveDown();
+            Class cls2 = (Class) this.javaClassConverter.fromString(hierarchicalStreamReader.getValue());
+            hierarchicalStreamReader.moveUp();
+            String str = null;
+            if (equals) {
+                hierarchicalStreamReader.moveDown();
+                str = hierarchicalStreamReader.getValue();
+                hierarchicalStreamReader.moveUp();
+            }
+            hierarchicalStreamReader.moveDown();
+            ArrayList arrayList = new ArrayList();
+            while (hierarchicalStreamReader.hasMoreChildren()) {
+                hierarchicalStreamReader.moveDown();
+                arrayList.add(this.javaClassConverter.fromString(hierarchicalStreamReader.getValue()));
+                hierarchicalStreamReader.moveUp();
+            }
+            Class<?>[] clsArr = (Class[]) arrayList.toArray(new Class[arrayList.size()]);
+            hierarchicalStreamReader.moveUp();
+            return equals ? cls2.getDeclaredMethod(str, clsArr) : cls2.getDeclaredConstructor(clsArr);
+        } catch (NoSuchMethodException e) {
+            throw new ConversionException(e);
+        }
+    }
+
+    public JavaMethodConverter(ClassLoader classLoader) {
+        this(new ClassLoaderReference(classLoader));
+    }
+
+    protected JavaMethodConverter(SingleValueConverter singleValueConverter) {
+        this.javaClassConverter = singleValueConverter;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/LocaleConverter.java

@@ -0,0 +1,58 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+public class LocaleConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$util$Locale;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private int[] underscorePositions(String str) {
+        int[] iArr = new int[2];
+        int i = 0;
+        while (i < iArr.length) {
+            iArr[i] = str.indexOf(95, (i == 0 ? 0 : iArr[i - 1]) + 1);
+            i++;
+        }
+        return iArr;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$Locale;
+        if (cls2 == null) {
+            cls2 = class$("java.util.Locale");
+            class$java$util$Locale = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        String substring;
+        String substring2;
+        int[] underscorePositions = underscorePositions(str);
+        String str2 = "";
+        if (underscorePositions[0] == -1) {
+            substring = str;
+            substring2 = "";
+        } else if (underscorePositions[1] == -1) {
+            substring = str.substring(0, underscorePositions[0]);
+            str2 = str.substring(underscorePositions[0] + 1);
+            substring2 = "";
+        } else {
+            substring = str.substring(0, underscorePositions[0]);
+            str2 = str.substring(underscorePositions[0] + 1, underscorePositions[1]);
+            substring2 = str.substring(underscorePositions[1] + 1);
+        }
+        return new Locale(substring, str2, substring2);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/LookAndFeelConverter.java

@@ -0,0 +1,37 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.reflection.ReflectionConverter;
+import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+public class LookAndFeelConverter extends ReflectionConverter {
+    static /* synthetic */ Class class$javax$swing$LookAndFeel;
+
+    public LookAndFeelConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
+        super(mapper, reflectionProvider);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.reflection.ReflectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$javax$swing$LookAndFeel;
+            if (cls2 == null) {
+                cls2 = class$("javax.swing.LookAndFeel");
+                class$javax$swing$LookAndFeel = cls2;
+            }
+            if (cls2.isAssignableFrom(cls) && canAccess(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/NamedArrayConverter.java

@@ -0,0 +1,100 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.core.util.Primitives;
+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.lang.reflect.Array;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public class NamedArrayConverter implements Converter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    private final Class arrayType;
+    private final String itemName;
+    private final Mapper mapper;
+
+    public NamedArrayConverter(Class cls, Mapper mapper, String str) {
+        if (cls.isArray()) {
+            this.arrayType = cls;
+            this.mapper = mapper;
+            this.itemName = str;
+        } else {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(cls.getName());
+            stringBuffer.append(" is not an array");
+            throw new IllegalArgumentException(stringBuffer.toString());
+        }
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls == this.arrayType;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Class<?> unbox;
+        String aliasForSystemAttribute;
+        int length = Array.getLength(obj);
+        for (int i = 0; i < length; i++) {
+            Object obj2 = Array.get(obj, i);
+            if (obj2 == null) {
+                unbox = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+                if (unbox == null) {
+                    unbox = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                    class$com$thoughtworks$xstream$mapper$Mapper$Null = unbox;
+                }
+            } else {
+                unbox = this.arrayType.getComponentType().isPrimitive() ? Primitives.unbox(obj2.getClass()) : obj2.getClass();
+            }
+            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.itemName, unbox);
+            if (!unbox.equals(this.arrayType.getComponentType()) && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class")) != null) {
+                hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(unbox));
+            }
+            if (obj2 != null) {
+                marshallingContext.convertAnother(obj2);
+            }
+            hierarchicalStreamWriter.endNode();
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        ArrayList arrayList = new ArrayList();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hierarchicalStreamReader.moveDown();
+            String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, this.mapper);
+            Class<?> componentType = readClassAttribute == null ? this.arrayType.getComponentType() : this.mapper.realClass(readClassAttribute);
+            Class cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+            if (cls == null) {
+                cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+            }
+            Object obj = null;
+            if (!cls.equals(componentType)) {
+                obj = unmarshallingContext.convertAnother(null, componentType);
+            }
+            arrayList.add(obj);
+            hierarchicalStreamReader.moveUp();
+        }
+        Object newInstance = Array.newInstance(this.arrayType.getComponentType(), arrayList.size());
+        for (int i = 0; i < arrayList.size(); i++) {
+            Array.set(newInstance, i, arrayList.get(i));
+        }
+        return newInstance;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/NamedCollectionConverter.java

@@ -0,0 +1,78 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.collections.CollectionConverter;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+
+/* loaded from: classes.dex */
+public class NamedCollectionConverter extends CollectionConverter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    private final String name;
+    private final Class type;
+
+    public NamedCollectionConverter(Mapper mapper, String str, Class cls) {
+        this(null, mapper, str, cls);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter
+    protected Object readBareItem(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Object obj) {
+        String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, mapper());
+        Class realClass = readClassAttribute == null ? this.type : mapper().realClass(readClassAttribute);
+        Class cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+        if (cls == null) {
+            cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+        }
+        if (cls.equals(realClass)) {
+            return null;
+        }
+        return unmarshallingContext.convertAnother(obj, realClass);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter
+    protected void writeCompleteItem(Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        writeItem(obj, marshallingContext, hierarchicalStreamWriter);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter
+    protected void writeItem(Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        Class<?> cls;
+        String aliasForSystemAttribute;
+        if (obj == null) {
+            cls = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+            if (cls == null) {
+                cls = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                class$com$thoughtworks$xstream$mapper$Mapper$Null = cls;
+            }
+        } else {
+            cls = obj.getClass();
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.name, cls);
+        if (!cls.equals(this.type) && (aliasForSystemAttribute = mapper().aliasForSystemAttribute("class")) != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, mapper().serializedClass(cls));
+        }
+        if (obj != null) {
+            marshallingContext.convertAnother(obj);
+        }
+        hierarchicalStreamWriter.endNode();
+    }
+
+    public NamedCollectionConverter(Class cls, Mapper mapper, String str, Class cls2) {
+        super(mapper, cls);
+        this.name = str;
+        this.type = cls2;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/NamedMapConverter.java

@@ -0,0 +1,220 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.ConverterLookup;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.collections.MapConverter;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+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.util.Map;
+
+/* loaded from: classes.dex */
+public class NamedMapConverter extends MapConverter {
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+    private final String entryName;
+    private final Mapper enumMapper;
+    private final boolean keyAsAttribute;
+    private final String keyName;
+    private final Class keyType;
+    private final ConverterLookup lookup;
+    private final boolean valueAsAttribute;
+    private final String valueName;
+    private final Class valueType;
+
+    public NamedMapConverter(Mapper mapper, String str, String str2, Class cls, String str3, Class cls2) {
+        this(mapper, str, str2, cls, str3, cls2, false, false, null);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private SingleValueConverter getSingleValueConverter(Class cls, String str) {
+        SingleValueConverter converterFromItemType = (UseAttributeForEnumMapper.isEnum(cls) ? this.enumMapper : mapper()).getConverterFromItemType(null, cls, null);
+        if (converterFromItemType != null) {
+            return converterFromItemType;
+        }
+        Converter lookupConverterForType = this.lookup.lookupConverterForType(cls);
+        if (lookupConverterForType instanceof SingleValueConverter) {
+            return (SingleValueConverter) lookupConverterForType;
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("No SingleValueConverter for ");
+        stringBuffer.append(str);
+        stringBuffer.append(" available");
+        throw new ConversionException(stringBuffer.toString());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter, com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Map map = (Map) obj;
+        SingleValueConverter singleValueConverter = this.keyAsAttribute ? getSingleValueConverter(this.keyType, "key") : null;
+        SingleValueConverter singleValueConverter2 = (this.valueAsAttribute || this.valueName == null) ? getSingleValueConverter(this.valueType, "value") : null;
+        for (Map.Entry entry : map.entrySet()) {
+            Object key = entry.getKey();
+            Object value = entry.getValue();
+            String str = this.entryName;
+            if (str != null) {
+                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, str, entry.getClass());
+                if (singleValueConverter != null && key != null) {
+                    hierarchicalStreamWriter.addAttribute(this.keyName, singleValueConverter.toString(key));
+                }
+                String str2 = this.valueName;
+                if (str2 != null && singleValueConverter2 != null && value != null) {
+                    hierarchicalStreamWriter.addAttribute(str2, singleValueConverter2.toString(value));
+                }
+            }
+            if (singleValueConverter == null) {
+                writeItem(this.keyName, this.keyType, key, marshallingContext, hierarchicalStreamWriter);
+            }
+            if (singleValueConverter2 == null) {
+                writeItem(this.valueName, this.valueType, value, marshallingContext, hierarchicalStreamWriter);
+            } else if (this.valueName == null) {
+                hierarchicalStreamWriter.setValue(singleValueConverter2.toString(value));
+            }
+            if (this.entryName != null) {
+                hierarchicalStreamWriter.endNode();
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.MapConverter
+    protected void populateMap(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Map map, Map map2) {
+        Object obj;
+        Object obj2;
+        String attribute;
+        String attribute2;
+        SingleValueConverter singleValueConverter = this.keyAsAttribute ? getSingleValueConverter(this.keyType, "key") : null;
+        SingleValueConverter singleValueConverter2 = (this.valueAsAttribute || this.valueName == null) ? getSingleValueConverter(this.valueType, "value") : null;
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            if (this.entryName != null) {
+                hierarchicalStreamReader.moveDown();
+                obj = (singleValueConverter == null || (attribute2 = hierarchicalStreamReader.getAttribute(this.keyName)) == null) ? null : singleValueConverter.fromString(attribute2);
+                obj2 = (!this.valueAsAttribute || singleValueConverter2 == null || (attribute = hierarchicalStreamReader.getAttribute(this.valueName)) == null) ? null : singleValueConverter2.fromString(attribute);
+            } else {
+                obj = null;
+                obj2 = null;
+            }
+            if (singleValueConverter == null) {
+                hierarchicalStreamReader.moveDown();
+                if (singleValueConverter2 == null && !this.keyName.equals(this.valueName) && hierarchicalStreamReader.getNodeName().equals(this.valueName)) {
+                    obj2 = readItem(this.valueType, hierarchicalStreamReader, unmarshallingContext, map);
+                } else {
+                    obj = readItem(this.keyType, hierarchicalStreamReader, unmarshallingContext, map);
+                }
+                hierarchicalStreamReader.moveUp();
+            }
+            if (singleValueConverter2 == null) {
+                hierarchicalStreamReader.moveDown();
+                if (singleValueConverter == null && obj == null && obj2 != null) {
+                    obj = readItem(this.keyType, hierarchicalStreamReader, unmarshallingContext, map);
+                } else {
+                    obj2 = readItem(this.valueType, hierarchicalStreamReader, unmarshallingContext, map);
+                }
+                hierarchicalStreamReader.moveUp();
+            } else if (!this.valueAsAttribute) {
+                obj2 = singleValueConverter2.fromString(hierarchicalStreamReader.getValue());
+            }
+            map2.put(obj, obj2);
+            if (this.entryName != null) {
+                hierarchicalStreamReader.moveUp();
+            }
+        }
+    }
+
+    protected Object readItem(Class cls, HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, Object obj) {
+        String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, mapper());
+        if (readClassAttribute != null) {
+            cls = mapper().realClass(readClassAttribute);
+        }
+        Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+        if (cls2 == null) {
+            cls2 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+            class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+        }
+        if (cls2.equals(cls)) {
+            return null;
+        }
+        return unmarshallingContext.convertAnother(obj, cls);
+    }
+
+    protected void writeItem(String str, Class cls, Object obj, MarshallingContext marshallingContext, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        Class<?> cls2;
+        String aliasForSystemAttribute;
+        if (obj == null) {
+            cls2 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+            }
+        } else {
+            cls2 = obj.getClass();
+        }
+        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, str, cls2);
+        if (!cls2.equals(cls) && (aliasForSystemAttribute = mapper().aliasForSystemAttribute("class")) != null) {
+            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, mapper().serializedClass(cls2));
+        }
+        if (obj != null) {
+            marshallingContext.convertAnother(obj);
+        }
+        hierarchicalStreamWriter.endNode();
+    }
+
+    public NamedMapConverter(Class cls, Mapper mapper, String str, String str2, Class cls2, String str3, Class cls3) {
+        this(cls, mapper, str, str2, cls2, str3, cls3, false, false, null);
+    }
+
+    public NamedMapConverter(Mapper mapper, String str, String str2, Class cls, String str3, Class cls2, boolean z, boolean z2, ConverterLookup converterLookup) {
+        this(null, mapper, str, str2, cls, str3, cls2, z, z2, converterLookup);
+    }
+
+    public NamedMapConverter(Class cls, Mapper mapper, String str, String str2, Class cls2, String str3, Class cls3, boolean z, boolean z2, ConverterLookup converterLookup) {
+        super(mapper, cls);
+        this.entryName = (str == null || str.length() != 0) ? str : null;
+        this.keyName = (str2 == null || str2.length() != 0) ? str2 : null;
+        this.keyType = cls2;
+        this.valueName = (str3 == null || str3.length() != 0) ? str3 : null;
+        this.valueType = cls3;
+        this.keyAsAttribute = z;
+        this.valueAsAttribute = z2;
+        this.lookup = converterLookup;
+        this.enumMapper = JVM.isVersion(5) ? UseAttributeForEnumMapper.createEnumMapper(mapper) : null;
+        if (cls2 == null || cls3 == null) {
+            throw new IllegalArgumentException("Class types of key and value are mandatory");
+        }
+        if (str == null) {
+            if (z || z2) {
+                throw new IllegalArgumentException("Cannot write attributes to map entry, if map entry must be omitted");
+            }
+            if (str3 == null) {
+                throw new IllegalArgumentException("Cannot write value as text of entry, if entry must be omitted");
+            }
+        }
+        if (str2 != null) {
+            if (str3 == null) {
+                if (z2) {
+                    throw new IllegalArgumentException("Cannot write value as attribute without name");
+                }
+                if (!z) {
+                    throw new IllegalArgumentException("Cannot write value as text of entry, if key is also child element");
+                }
+            }
+            if (z && z2 && str2.equals(str3)) {
+                throw new IllegalArgumentException("Cannot write key and value with same attribute name");
+            }
+            return;
+        }
+        throw new IllegalArgumentException("Cannot write key without name");
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/PathConverter.java

@@ -0,0 +1,47 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.FileSystems;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/* loaded from: classes.dex */
+public class PathConverter extends AbstractSingleValueConverter {
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return cls != null && Path.class.isAssignableFrom(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Path path = (Path) obj;
+        if (path.getFileSystem() != FileSystems.getDefault()) {
+            return path.toUri().toString();
+        }
+        String path2 = path.toString();
+        char c = File.separatorChar;
+        return c != '/' ? path2.replace(c, '/') : path2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Path fromString(String str) {
+        try {
+            try {
+                URI uri = new URI(str);
+                if (uri.getScheme() != null && uri.getScheme().length() != 1) {
+                    return Paths.get(uri);
+                }
+                return Paths.get(File.separatorChar != '/' ? str.replace('/', File.separatorChar) : str, new String[0]);
+            } catch (URISyntaxException unused) {
+                return Paths.get(str, new String[0]);
+            }
+        } catch (InvalidPathException e) {
+            throw new ConversionException(e);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/PropertyEditorCapableConverter.java

@@ -0,0 +1,30 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.core.util.ThreadSafePropertyEditor;
+
+/* loaded from: classes.dex */
+public class PropertyEditorCapableConverter implements SingleValueConverter {
+    private final ThreadSafePropertyEditor editor;
+    private final Class type;
+
+    public PropertyEditorCapableConverter(Class cls, Class cls2) {
+        this.type = cls2;
+        this.editor = new ThreadSafePropertyEditor(cls, 2, 5);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return this.type == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return this.editor.setAsText(str);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return this.editor.getAsText(obj);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/RegexPatternConverter.java

@@ -0,0 +1,59 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import java.util.regex.Pattern;
+
+/* loaded from: classes.dex */
+public class RegexPatternConverter implements Converter {
+    static /* synthetic */ Class class$java$util$regex$Pattern;
+
+    public RegexPatternConverter() {
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$util$regex$Pattern;
+        if (cls2 == null) {
+            cls2 = class$("java.util.regex.Pattern");
+            class$java$util$regex$Pattern = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Pattern pattern = (Pattern) obj;
+        hierarchicalStreamWriter.startNode("pattern");
+        hierarchicalStreamWriter.setValue(pattern.pattern());
+        hierarchicalStreamWriter.endNode();
+        hierarchicalStreamWriter.startNode("flags");
+        hierarchicalStreamWriter.setValue(String.valueOf(pattern.flags()));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        hierarchicalStreamReader.moveDown();
+        String value = hierarchicalStreamReader.getValue();
+        hierarchicalStreamReader.moveUp();
+        hierarchicalStreamReader.moveDown();
+        int parseInt = Integer.parseInt(hierarchicalStreamReader.getValue());
+        hierarchicalStreamReader.moveUp();
+        return Pattern.compile(value, parseInt);
+    }
+
+    public RegexPatternConverter(Converter converter) {
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/SqlDateConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.sql.Date;
+
+/* loaded from: classes.dex */
+public class SqlDateConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$sql$Date;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$sql$Date;
+        if (cls2 == null) {
+            cls2 = class$("java.sql.Date");
+            class$java$sql$Date = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Date.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/SqlTimeConverter.java

@@ -0,0 +1,32 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.sql.Time;
+
+/* loaded from: classes.dex */
+public class SqlTimeConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$sql$Time;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$sql$Time;
+        if (cls2 == null) {
+            cls2 = class$("java.sql.Time");
+            class$java$sql$Time = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        return Time.valueOf(str);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/SqlTimestampConverter.java

@@ -0,0 +1,79 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import com.thoughtworks.xstream.core.util.ThreadSafeSimpleDateFormat;
+import java.sql.Timestamp;
+import java.text.ParseException;
+import java.util.TimeZone;
+
+/* loaded from: classes.dex */
+public class SqlTimestampConverter extends AbstractSingleValueConverter {
+    static /* synthetic */ Class class$java$sql$Timestamp;
+    private final ThreadSafeSimpleDateFormat format;
+
+    public SqlTimestampConverter() {
+        this(TimeZone.getTimeZone("UTC"));
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$sql$Timestamp;
+        if (cls2 == null) {
+            cls2 = class$("java.sql.Timestamp");
+            class$java$sql$Timestamp = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        int lastIndexOf = str.lastIndexOf(46);
+        if (lastIndexOf > 0 && (str.length() - lastIndexOf < 2 || str.length() - lastIndexOf > 10)) {
+            throw new ConversionException("Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]");
+        }
+        try {
+            Timestamp timestamp = new Timestamp(this.format.parse(lastIndexOf < 0 ? str : str.substring(0, lastIndexOf)).getTime());
+            if (lastIndexOf > 0) {
+                StringBuffer stringBuffer = new StringBuffer(str.substring(lastIndexOf + 1));
+                while (stringBuffer.length() != 9) {
+                    stringBuffer.append('0');
+                }
+                timestamp.setNanos(Integer.parseInt(stringBuffer.toString()));
+            }
+            return timestamp;
+        } catch (NumberFormatException e) {
+            throw new ConversionException("Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]", e);
+        } catch (ParseException e2) {
+            throw new ConversionException("Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]", e2);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        Timestamp timestamp = (Timestamp) obj;
+        StringBuffer stringBuffer = new StringBuffer(this.format.format(timestamp));
+        if (timestamp.getNanos() != 0) {
+            stringBuffer.append('.');
+            String valueOf = String.valueOf(timestamp.getNanos() + 1000000000);
+            int i = 10;
+            while (i > 2 && valueOf.charAt(i - 1) == '0') {
+                i--;
+            }
+            stringBuffer.append(valueOf.subSequence(1, i));
+        }
+        return stringBuffer.toString();
+    }
+
+    public SqlTimestampConverter(TimeZone timeZone) {
+        this.format = new ThreadSafeSimpleDateFormat("yyyy-MM-dd HH:mm:ss", timeZone, 0, 5, false);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/StackTraceElementConverter.java

@@ -0,0 +1,95 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes.dex */
+public class StackTraceElementConverter extends AbstractSingleValueConverter {
+    private static final StackTraceElementFactory FACTORY;
+    private static final Pattern PATTERN = Pattern.compile("^(.+)\\.([^\\(]+)\\(([^:]*)(:(\\d+))?\\)$");
+    static /* synthetic */ Class class$java$lang$StackTraceElement;
+
+    /* JADX WARN: Can't wrap try/catch for region: R(10:0|1|(9:3|4|5|(1:7)|8|9|10|11|12)|18|(0)|8|9|10|11|12) */
+    /* JADX WARN: Removed duplicated region for block: B:7:0x0021  */
+    static {
+        /*
+            java.lang.String r0 = "^(.+)\\.([^\\(]+)\\(([^:]*)(:(\\d+))?\\)$"
+            java.util.regex.Pattern r0 = java.util.regex.Pattern.compile(r0)
+            com.thoughtworks.xstream.converters.extended.StackTraceElementConverter.PATTERN = r0
+            r0 = 5
+            boolean r0 = com.thoughtworks.xstream.core.JVM.isVersion(r0)
+            r1 = 0
+            if (r0 == 0) goto L1e
+            r0 = 0
+            java.lang.String r2 = "com.thoughtworks.xstream.converters.extended.StackTraceElementFactory15"
+            java.lang.Class r0 = com.thoughtworks.xstream.core.JVM.loadClassForName(r2, r0)
+            java.lang.Object r0 = r0.newInstance()     // Catch: java.lang.Throwable -> L1e
+            com.thoughtworks.xstream.converters.extended.StackTraceElementFactory r0 = (com.thoughtworks.xstream.converters.extended.StackTraceElementFactory) r0     // Catch: java.lang.Throwable -> L1e
+            goto L1f
+        L1e:
+            r0 = r1
+        L1f:
+            if (r0 != 0) goto L26
+            com.thoughtworks.xstream.converters.extended.StackTraceElementFactory r0 = new com.thoughtworks.xstream.converters.extended.StackTraceElementFactory
+            r0.<init>()
+        L26:
+            java.lang.String r2 = "a"
+            java.lang.String r3 = "b"
+            r0.unknownSourceElement(r2, r3)     // Catch: java.lang.Throwable -> L2e
+            r1 = r0
+        L2e:
+            com.thoughtworks.xstream.converters.extended.StackTraceElementConverter.FACTORY = r1
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.extended.StackTraceElementConverter.<clinit>():void");
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$java$lang$StackTraceElement;
+        if (cls2 == null) {
+            cls2 = class$("java.lang.StackTraceElement");
+            class$java$lang$StackTraceElement = cls2;
+        }
+        return cls2.equals(cls) && FACTORY != null;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public Object fromString(String str) {
+        Matcher matcher = PATTERN.matcher(str);
+        if (!matcher.matches()) {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append("Could not parse StackTraceElement : ");
+            stringBuffer.append(str);
+            throw new ConversionException(stringBuffer.toString());
+        }
+        String group = matcher.group(1);
+        String group2 = matcher.group(2);
+        String group3 = matcher.group(3);
+        if (group3.equals("Unknown Source")) {
+            return FACTORY.unknownSourceElement(group, group2);
+        }
+        if (group3.equals("Native Method")) {
+            return FACTORY.nativeMethodElement(group, group2);
+        }
+        if (matcher.group(4) == null) {
+            return FACTORY.element(group, group2, group3);
+        }
+        return FACTORY.element(group, group2, group3, Integer.parseInt(matcher.group(5)));
+    }
+
+    @Override // com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter, com.thoughtworks.xstream.converters.SingleValueConverter
+    public String toString(Object obj) {
+        return super.toString(obj).replaceFirst(":\\?\\?\\?", "");
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/StackTraceElementFactory.java

@@ -0,0 +1,50 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.core.util.Fields;
+
+/* loaded from: classes.dex */
+public class StackTraceElementFactory {
+    static /* synthetic */ Class class$java$lang$StackTraceElement;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private void setField(StackTraceElement stackTraceElement, String str, Object obj) {
+        Class cls = class$java$lang$StackTraceElement;
+        if (cls == null) {
+            cls = class$("java.lang.StackTraceElement");
+            class$java$lang$StackTraceElement = cls;
+        }
+        Fields.write(Fields.find(cls, str), stackTraceElement, obj);
+    }
+
+    protected StackTraceElement create(String str, String str2, String str3, int i) {
+        StackTraceElement stackTraceElement = new Throwable().getStackTrace()[0];
+        setField(stackTraceElement, "declaringClass", str);
+        setField(stackTraceElement, "methodName", str2);
+        setField(stackTraceElement, "fileName", str3);
+        setField(stackTraceElement, "lineNumber", new Integer(i));
+        return stackTraceElement;
+    }
+
+    public StackTraceElement element(String str, String str2, String str3) {
+        return create(str, str2, str3, -1);
+    }
+
+    public StackTraceElement nativeMethodElement(String str, String str2) {
+        return create(str, str2, "Native Method", -2);
+    }
+
+    public StackTraceElement unknownSourceElement(String str, String str2) {
+        return create(str, str2, "Unknown Source", -1);
+    }
+
+    public StackTraceElement element(String str, String str2, String str3, int i) {
+        return create(str, str2, str3, i);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/StackTraceElementFactory15.java

@@ -0,0 +1,12 @@
+package com.thoughtworks.xstream.converters.extended;
+
+/* loaded from: classes.dex */
+class StackTraceElementFactory15 extends StackTraceElementFactory {
+    StackTraceElementFactory15() {
+    }
+
+    @Override // com.thoughtworks.xstream.converters.extended.StackTraceElementFactory
+    protected StackTraceElement create(String str, String str2, String str3, int i) {
+        return new StackTraceElement(str, str2, str3, i);
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/SubjectConverter.java

@@ -0,0 +1,104 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import javax.security.auth.Subject;
+
+/* loaded from: classes.dex */
+public class SubjectConverter extends AbstractCollectionConverter {
+    static /* synthetic */ Class class$javax$security$auth$Subject;
+
+    public SubjectConverter(Mapper mapper) {
+        super(mapper);
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        Class cls2 = class$javax$security$auth$Subject;
+        if (cls2 == null) {
+            cls2 = class$("javax.security.auth.Subject");
+            class$javax$security$auth$Subject = cls2;
+        }
+        return cls == cls2;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Subject subject = (Subject) obj;
+        marshalPrincipals(subject.getPrincipals(), hierarchicalStreamWriter, marshallingContext);
+        marshalPublicCredentials(subject.getPublicCredentials(), hierarchicalStreamWriter, marshallingContext);
+        marshalPrivateCredentials(subject.getPrivateCredentials(), hierarchicalStreamWriter, marshallingContext);
+        marshalReadOnly(subject.isReadOnly(), hierarchicalStreamWriter);
+    }
+
+    protected void marshalPrincipals(Set set, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        hierarchicalStreamWriter.startNode("principals");
+        Iterator it = set.iterator();
+        while (it.hasNext()) {
+            writeCompleteItem(it.next(), marshallingContext, hierarchicalStreamWriter);
+        }
+        hierarchicalStreamWriter.endNode();
+    }
+
+    protected void marshalPrivateCredentials(Set set, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+    }
+
+    protected void marshalPublicCredentials(Set set, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+    }
+
+    protected void marshalReadOnly(boolean z, HierarchicalStreamWriter hierarchicalStreamWriter) {
+        hierarchicalStreamWriter.startNode("readOnly");
+        hierarchicalStreamWriter.setValue(String.valueOf(z));
+        hierarchicalStreamWriter.endNode();
+    }
+
+    protected Set populateSet(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        HashSet hashSet = new HashSet();
+        hierarchicalStreamReader.moveDown();
+        while (hierarchicalStreamReader.hasMoreChildren()) {
+            hashSet.add(readCompleteItem(hierarchicalStreamReader, unmarshallingContext, hashSet));
+        }
+        hierarchicalStreamReader.moveUp();
+        return hashSet;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter, com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return new Subject(unmarshalReadOnly(hierarchicalStreamReader), unmarshalPrincipals(hierarchicalStreamReader, unmarshallingContext), unmarshalPublicCredentials(hierarchicalStreamReader, unmarshallingContext), unmarshalPrivateCredentials(hierarchicalStreamReader, unmarshallingContext));
+    }
+
+    protected Set unmarshalPrincipals(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return populateSet(hierarchicalStreamReader, unmarshallingContext);
+    }
+
+    protected Set unmarshalPrivateCredentials(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return Collections.EMPTY_SET;
+    }
+
+    protected Set unmarshalPublicCredentials(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return Collections.EMPTY_SET;
+    }
+
+    protected boolean unmarshalReadOnly(HierarchicalStreamReader hierarchicalStreamReader) {
+        hierarchicalStreamReader.moveDown();
+        boolean z = Boolean.getBoolean(hierarchicalStreamReader.getValue());
+        hierarchicalStreamReader.moveUp();
+        return z;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/TextAttributeConverter.java

@@ -0,0 +1,36 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.reflection.AbstractAttributedCharacterIteratorAttributeConverter;
+
+/* loaded from: classes.dex */
+public class TextAttributeConverter extends AbstractAttributedCharacterIteratorAttributeConverter {
+    static /* synthetic */ Class class$java$awt$font$TextAttribute;
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public TextAttributeConverter() {
+        /*
+            r1 = this;
+            java.lang.Class r0 = com.thoughtworks.xstream.converters.extended.TextAttributeConverter.class$java$awt$font$TextAttribute
+            if (r0 != 0) goto Lc
+            java.lang.String r0 = "java.awt.font.TextAttribute"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.converters.extended.TextAttributeConverter.class$java$awt$font$TextAttribute = r0
+        Lc:
+            r1.<init>(r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.extended.TextAttributeConverter.<init>():void");
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ThrowableConverter.java

@@ -0,0 +1,80 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.ConverterLookup;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+
+/* loaded from: classes.dex */
+public class ThrowableConverter implements Converter {
+    static /* synthetic */ Class class$java$lang$Object;
+    static /* synthetic */ Class class$java$lang$Throwable;
+    private Converter defaultConverter;
+    private final ConverterLookup lookup;
+
+    public ThrowableConverter(Converter converter) {
+        this.defaultConverter = converter;
+        this.lookup = null;
+    }
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    private Converter getConverter() {
+        Converter converter = this.defaultConverter;
+        if (converter != null) {
+            return converter;
+        }
+        ConverterLookup converterLookup = this.lookup;
+        Class cls = class$java$lang$Object;
+        if (cls == null) {
+            cls = class$("java.lang.Object");
+            class$java$lang$Object = cls;
+        }
+        return converterLookup.lookupConverterForType(cls);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$java$lang$Throwable;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Throwable");
+                class$java$lang$Throwable = cls2;
+            }
+            if (cls2.isAssignableFrom(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        Throwable th = (Throwable) obj;
+        if (th.getCause() == null) {
+            try {
+                th.initCause(null);
+            } catch (IllegalStateException unused) {
+            }
+        }
+        th.getStackTrace();
+        getConverter().marshal(th, hierarchicalStreamWriter, marshallingContext);
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        return getConverter().unmarshal(hierarchicalStreamReader, unmarshallingContext);
+    }
+
+    public ThrowableConverter(ConverterLookup converterLookup) {
+        this.lookup = converterLookup;
+    }
+}

sources/com/thoughtworks/xstream/converters/extended/ToAttributedValueConverter.java

@@ -0,0 +1,258 @@
+package com.thoughtworks.xstream.converters.extended;
+
+import com.thoughtworks.xstream.converters.ConversionException;
+import com.thoughtworks.xstream.converters.Converter;
+import com.thoughtworks.xstream.converters.ConverterLookup;
+import com.thoughtworks.xstream.converters.ConverterMatcher;
+import com.thoughtworks.xstream.converters.MarshallingContext;
+import com.thoughtworks.xstream.converters.SingleValueConverter;
+import com.thoughtworks.xstream.converters.UnmarshallingContext;
+import com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter;
+import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
+import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.core.util.FastField;
+import com.thoughtworks.xstream.core.util.HierarchicalStreams;
+import com.thoughtworks.xstream.core.util.Primitives;
+import com.thoughtworks.xstream.io.HierarchicalStreamReader;
+import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
+import com.thoughtworks.xstream.mapper.Mapper;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class ToAttributedValueConverter implements Converter {
+    private static final String STRUCTURE_MARKER = "";
+    private final Mapper enumMapper;
+    private final ConverterLookup lookup;
+    private final Mapper mapper;
+    private final ReflectionProvider reflectionProvider;
+    private final Class type;
+    private final Field valueField;
+
+    public ToAttributedValueConverter(Class cls, Mapper mapper, ReflectionProvider reflectionProvider, ConverterLookup converterLookup) {
+        this(cls, mapper, reflectionProvider, converterLookup, null, null);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public boolean fieldIsEqual(FastField fastField) {
+        return this.valueField.getName().equals(fastField.getName()) && this.valueField.getDeclaringClass().getName().equals(fastField.getDeclaringClass());
+    }
+
+    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
+    public boolean canConvert(Class cls) {
+        return this.type == cls;
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public void marshal(Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
+        String aliasForSystemAttribute;
+        final Class<?> cls = obj.getClass();
+        final HashMap hashMap = new HashMap();
+        final String[] strArr = new String[1];
+        final Object[] objArr = new Object[1];
+        final Class[] clsArr = new Class[1];
+        final Class[] clsArr2 = new Class[1];
+        this.reflectionProvider.visitSerializableFields(obj, new ReflectionProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.extended.ToAttributedValueConverter.1
+            @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor
+            public void visit(String str, Class cls2, Class cls3, Object obj2) {
+                if (ToAttributedValueConverter.this.mapper.shouldSerializeMember(cls3, str)) {
+                    FastField fastField = new FastField(cls3, str);
+                    String serializedMember = ToAttributedValueConverter.this.mapper.serializedMember(cls3, str);
+                    if (!hashMap.containsKey(serializedMember)) {
+                        hashMap.put(serializedMember, ToAttributedValueConverter.this.reflectionProvider.getField(cls, str));
+                    } else if (!ToAttributedValueConverter.this.fieldIsEqual(fastField)) {
+                        ConversionException conversionException = new ConversionException("Cannot write attribute twice for object");
+                        conversionException.add("alias", serializedMember);
+                        conversionException.add("type", cls.getName());
+                        throw conversionException;
+                    }
+                    ConverterMatcher converterFromItemType = UseAttributeForEnumMapper.isEnum(cls2) ? ToAttributedValueConverter.this.enumMapper.getConverterFromItemType(null, cls2, null) : ToAttributedValueConverter.this.mapper.getLocalConverter(cls3, str);
+                    if (converterFromItemType == null) {
+                        converterFromItemType = ToAttributedValueConverter.this.lookup.lookupConverterForType(cls2);
+                    }
+                    if (obj2 != null) {
+                        boolean z = ToAttributedValueConverter.this.valueField != null && ToAttributedValueConverter.this.fieldIsEqual(fastField);
+                        if (z) {
+                            clsArr2[0] = cls3;
+                            clsArr[0] = cls2;
+                            objArr[0] = obj2;
+                            strArr[0] = "";
+                        }
+                        if (!(converterFromItemType instanceof SingleValueConverter)) {
+                            if (z) {
+                                return;
+                            }
+                            ConversionException conversionException2 = new ConversionException("Cannot write element as attribute");
+                            conversionException2.add("alias", serializedMember);
+                            conversionException2.add("type", cls.getName());
+                            throw conversionException2;
+                        }
+                        String singleValueConverter = ((SingleValueConverter) converterFromItemType).toString(obj2);
+                        if (z) {
+                            strArr[0] = singleValueConverter;
+                        } else if (singleValueConverter != null) {
+                            hierarchicalStreamWriter.addAttribute(serializedMember, singleValueConverter);
+                        }
+                    }
+                }
+            }
+        });
+        if (strArr[0] != null) {
+            Class<?> cls2 = objArr[0].getClass();
+            Class defaultImplementationOf = this.mapper.defaultImplementationOf(clsArr[0]);
+            if (!cls2.equals(defaultImplementationOf)) {
+                String serializedClass = this.mapper.serializedClass(cls2);
+                if (!serializedClass.equals(this.mapper.serializedClass(defaultImplementationOf)) && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class")) != null) {
+                    hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, serializedClass);
+                }
+            }
+            if (strArr[0] == "") {
+                marshallingContext.convertAnother(objArr[0]);
+            } else {
+                hierarchicalStreamWriter.setValue(strArr[0]);
+            }
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.converters.Converter
+    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
+        Class<?> cls;
+        Iterator it;
+        HashSet hashSet;
+        ConverterMatcher localConverter;
+        Object newInstance = this.reflectionProvider.newInstance(unmarshallingContext.getRequiredType());
+        Class<?> cls2 = newInstance.getClass();
+        HashSet hashSet2 = new HashSet();
+        Iterator attributeNames = hierarchicalStreamReader.getAttributeNames();
+        HashSet hashSet3 = new HashSet();
+        hashSet3.add(this.mapper.aliasForSystemAttribute("class"));
+        while (attributeNames.hasNext()) {
+            String str = (String) attributeNames.next();
+            if (!hashSet3.contains(str)) {
+                String realMember = this.mapper.realMember(cls2, str);
+                Field fieldOrNull = this.reflectionProvider.getFieldOrNull(cls2, realMember);
+                if (fieldOrNull == null) {
+                    cls = cls2;
+                    it = attributeNames;
+                    hashSet = hashSet3;
+                } else if (Modifier.isTransient(fieldOrNull.getModifiers())) {
+                    continue;
+                } else {
+                    it = attributeNames;
+                    Class<?> type = fieldOrNull.getType();
+                    Class<?> declaringClass = fieldOrNull.getDeclaringClass();
+                    if (UseAttributeForEnumMapper.isEnum(type)) {
+                        hashSet = hashSet3;
+                        cls = cls2;
+                        localConverter = this.enumMapper.getConverterFromItemType(null, type, null);
+                    } else {
+                        cls = cls2;
+                        hashSet = hashSet3;
+                        localConverter = this.mapper.getLocalConverter(declaringClass, realMember);
+                    }
+                    if (localConverter == null) {
+                        localConverter = this.lookup.lookupConverterForType(type);
+                    }
+                    if (!(localConverter instanceof SingleValueConverter)) {
+                        ConversionException conversionException = new ConversionException("Cannot read field as a single value for object");
+                        conversionException.add("field", realMember);
+                        conversionException.add("type", cls.getName());
+                        throw conversionException;
+                    }
+                    if (localConverter != null) {
+                        Object fromString = ((SingleValueConverter) localConverter).fromString(hierarchicalStreamReader.getAttribute(str));
+                        if (type.isPrimitive()) {
+                            type = Primitives.box(type);
+                        }
+                        if (fromString != null && !type.isAssignableFrom(fromString.getClass())) {
+                            ConversionException conversionException2 = new ConversionException("Cannot assign object to type");
+                            conversionException2.add("object type", fromString.getClass().getName());
+                            conversionException2.add("target type", type.getName());
+                            throw conversionException2;
+                        }
+                        this.reflectionProvider.writeField(newInstance, realMember, fromString, declaringClass);
+                        if (!hashSet2.add(new FastField(declaringClass, realMember))) {
+                            StringBuffer stringBuffer = new StringBuffer();
+                            stringBuffer.append(realMember);
+                            stringBuffer.append(" [");
+                            stringBuffer.append(declaringClass.getName());
+                            stringBuffer.append("]");
+                            throw new AbstractReflectionConverter.DuplicateFieldException(stringBuffer.toString());
+                        }
+                    }
+                }
+                attributeNames = it;
+                hashSet3 = hashSet;
+                cls2 = cls;
+            }
+        }
+        Field field = this.valueField;
+        if (field != null) {
+            Class<?> declaringClass2 = field.getDeclaringClass();
+            String name = this.valueField.getName();
+            Field field2 = name == null ? null : this.reflectionProvider.getField(declaringClass2, name);
+            if (name == null || field2 == null) {
+                ConversionException conversionException3 = new ConversionException("Cannot assign value to field of type");
+                conversionException3.add("element", hierarchicalStreamReader.getNodeName());
+                conversionException3.add("field", name);
+                conversionException3.add("target type", unmarshallingContext.getRequiredType().getName());
+                throw conversionException3;
+            }
+            String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, this.mapper);
+            Class realClass = readClassAttribute != null ? this.mapper.realClass(readClassAttribute) : this.mapper.defaultImplementationOf(this.reflectionProvider.getFieldType(newInstance, name, declaringClass2));
+            Object convertAnother = unmarshallingContext.convertAnother(newInstance, realClass, this.mapper.getLocalConverter(field2.getDeclaringClass(), field2.getName()));
+            Class fieldType = this.reflectionProvider.getFieldType(newInstance, name, declaringClass2);
+            if (!fieldType.isPrimitive()) {
+                realClass = fieldType;
+            }
+            if (convertAnother != null && !realClass.isAssignableFrom(convertAnother.getClass())) {
+                ConversionException conversionException4 = new ConversionException("Cannot assign object to type");
+                conversionException4.add("object type", convertAnother.getClass().getName());
+                conversionException4.add("target type", realClass.getName());
+                throw conversionException4;
+            }
+            this.reflectionProvider.writeField(newInstance, name, convertAnother, declaringClass2);
+            if (!hashSet2.add(new FastField(declaringClass2, name))) {
+                StringBuffer stringBuffer2 = new StringBuffer();
+                stringBuffer2.append(name);
+                stringBuffer2.append(" [");
+                stringBuffer2.append(declaringClass2.getName());
+                stringBuffer2.append("]");
+                throw new AbstractReflectionConverter.DuplicateFieldException(stringBuffer2.toString());
+            }
+        }
+        return newInstance;
+    }
+
+    public ToAttributedValueConverter(Class cls, Mapper mapper, ReflectionProvider reflectionProvider, ConverterLookup converterLookup, String str) {
+        this(cls, mapper, reflectionProvider, converterLookup, str, null);
+    }
+
+    public ToAttributedValueConverter(Class cls, Mapper mapper, ReflectionProvider reflectionProvider, ConverterLookup converterLookup, String str, Class cls2) {
+        this.type = cls;
+        this.mapper = mapper;
+        this.reflectionProvider = reflectionProvider;
+        this.lookup = converterLookup;
+        if (str == null) {
+            this.valueField = null;
+        } else {
+            try {
+                Field declaredField = (cls2 != null ? cls2 : cls).getDeclaredField(str);
+                if (!declaredField.isAccessible()) {
+                    declaredField.setAccessible(true);
+                }
+                this.valueField = declaredField;
+            } catch (NoSuchFieldException e) {
+                StringBuffer stringBuffer = new StringBuffer();
+                stringBuffer.append(e.getMessage());
+                stringBuffer.append(": ");
+                stringBuffer.append(str);
+                throw new IllegalArgumentException(stringBuffer.toString());
+            }
+        }
+        this.enumMapper = JVM.isVersion(5) ? UseAttributeForEnumMapper.createEnumMapper(mapper) : null;
+    }
+}